def pygame_demo_image():
# this function is for demoing a default output
size,polygons,poly_sites,rivers,cities,roads,regions = setup()
pygame.init()
pygame.font.init()
screen = pygame.display.set_mode(size,pygame.RESIZABLE)
pygame.display.set_caption('Map')
city_font = pygame.font.SysFont('arial', 20)
region_font = pygame.font.SysFont('arial', 30)
simple_render(polygons,poly_sites,rivers,cities,roads,regions,city_font,region_font,flag=True)
pygame.image.save(screen,'test.png')
pygame.quit()
python类RESIZABLE的实例源码
def _run_pygame_cb(self, main_fn):
assert pygame.display.get_surface() is None, "PygameCanvas.run_pygame can only be called once."
# Preinitialize Pygame with the X window ID.
assert pygame.display.get_init() == False, "Pygame must not be initialized before calling PygameCanvas.run_pygame."
os.environ['SDL_WINDOWID'] = str(self._socket.get_id())
pygame.init()
# Restore the default cursor.
self._socket.props.window.set_cursor(None)
# Initialize the Pygame window.
r = self.get_allocation()
pygame.display.set_mode((r.width, r.height), pygame.RESIZABLE)
# Hook certain Pygame functions with GTK equivalents.
self.translator.hook_pygame()
# Run the Pygame main loop.
main_fn()
return False
def handle_events(*args):
settings_window, camera, scroll, done, dims, screen, bodies, G, COR = args
for event in pg.event.get():
if event.type == pg.VIDEORESIZE:
width, height = event.w, event.h
dims, screen = V2(width, height), pg.display.set_mode((width, height), pg.RESIZABLE)
elif event.type == pg.KEYDOWN:
scroll.key(event.key, 1)
camera.key_down(event.key)
elif event.type == pg.KEYUP:
scroll.key(event.key, 0)
camera.key_up(event.key)
elif event.type == pg.MOUSEBUTTONDOWN:
handle_mouse(settings_window, camera, event, bodies, dims, G, COR, scroll)
done |= event.type == pg.QUIT
return done, dims, screen
def fullscreen_toggle(self, info):
"""toggle between fullscreen and windowed version with CTRL + F
current activity will be reset"""
self.redraw_needed = [True, True, True]
if self.config.fullscreen is True:
self.config.fullscreen = False
self.size = self.wn_size[:]
self.screen = pygame.display.set_mode(self.size, pygame.RESIZABLE)
self.fs_rescale(info)
else:
self.config.fullscreen = True
self.size = self.fs_size[:]
self.screen = pygame.display.set_mode(self.size, pygame.FULLSCREEN)
self.fs_rescale(info)
pygame.display.flip()
def _run_pygame_cb(self, main_fn):
assert pygame.display.get_surface() is None, "PygameCanvas.run_pygame can only be called once."
# Preinitialize Pygame with the X window ID.
assert pygame.display.get_init() == False, "Pygame must not be initialized before calling PygameCanvas.run_pygame."
os.environ['SDL_WINDOWID'] = str(self._socket.get_id())
pygame.init()
# Restore the default cursor.
self._socket.props.window.set_cursor(None)
# Initialize the Pygame window.
r = self.get_allocation()
pygame.display.set_mode((r.width, r.height), pygame.RESIZABLE)
# Hook certain Pygame functions with GTK equivalents.
self.translator.hook_pygame()
# Run the Pygame main loop.
main_fn()
return False
def _run_pygame_cb(self, main_fn):
assert pygame.display.get_surface() is None, "PygameCanvas.run_pygame can only be called once."
# Preinitialize Pygame with the X window ID.
assert pygame.display.get_init() == False, "Pygame must not be initialized before calling PygameCanvas.run_pygame."
os.environ['SDL_WINDOWID'] = str(self._socket.get_id())
pygame.init()
# Restore the default cursor.
self._socket.props.window.set_cursor(None)
# Initialize the Pygame window.
r = self.get_allocation()
pygame.display.set_mode((r.width, r.height), pygame.RESIZABLE)
# Hook certain Pygame functions with GTK equivalents.
self.translator.hook_pygame()
# Run the Pygame main loop.
main_fn()
return False
def _pygameMode(self, n): return pygame.RESIZABLE if n is True else int(n)
def main():
pygame.init()
pygame.display.set_mode((1200, 900), pygame.RESIZABLE)
game_instance = PyCut()
game_instance.run()
def init_display():
pg.init()
info = pg.display.Info()
dims = (int(info.current_w * 0.6), int(info.current_h * 0.75))
os.environ['SDL_VIDEO_CENTERED'] = '1'
pg.display.set_icon(pg.image.load('AtomIcon.png'))
screen = pg.display.set_mode(dims, pg.RESIZABLE)
pg.display.set_caption("Physics Simulator 2.0")
return screen, V2(dims)
def __init__(self):
pygame.init()
# Used to manage how fast the screen updates
self._clock = pygame.time.Clock()
# Loop until the user clicks the close button.
self._done = False
# Used to manage how fast the screen updates
self._clock = pygame.time.Clock()
# Kinect runtime object, we want only color and body frames
self._kinect = PyKinectRuntime.PyKinectRuntime(PyKinectV2.FrameSourceTypes_Infrared)
# back buffer surface for getting Kinect infrared frames, 8bit grey, width and height equal to the Kinect color frame size
self._frame_surface = pygame.Surface((self._kinect.infrared_frame_desc.Width, self._kinect.infrared_frame_desc.Height), 0, 24)
# here we will store skeleton data
self._bodies = None
# Set the width and height of the screen [width, height]
self._infoObject = pygame.display.Info()
self._screen = pygame.display.set_mode((self._kinect.infrared_frame_desc.Width, self._kinect.infrared_frame_desc.Height),
pygame.HWSURFACE|pygame.DOUBLEBUF|pygame.RESIZABLE, 32)
pygame.display.set_caption("Kinect for Windows v2 Infrared")
def run(self):
# -------- Main Program Loop -----------
while not self._done:
# --- Main event loop
for event in pygame.event.get(): # User did something
if event.type == pygame.QUIT: # If user clicked close
self._done = True # Flag that we are done so we exit this loop
elif event.type == pygame.VIDEORESIZE: # window resized
self._screen = pygame.display.set_mode(event.dict['size'],
pygame.HWSURFACE|pygame.DOUBLEBUF|pygame.RESIZABLE, 32)
# --- Getting frames and drawing
if self._kinect.has_new_infrared_frame():
frame = self._kinect.get_last_infrared_frame()
self.draw_infrared_frame(frame, self._frame_surface)
frame = None
self._screen.blit(self._frame_surface, (0,0))
pygame.display.update()
# --- Go ahead and update the screen with what we've drawn.
pygame.display.flip()
# --- Limit to 60 frames per second
self._clock.tick(60)
# Close our Kinect sensor, close the window and quit.
self._kinect.close()
pygame.quit()
def __init__(self):
pygame.init()
# Used to manage how fast the screen updates
self._clock = pygame.time.Clock()
# Set the width and height of the screen [width, height]
self._infoObject = pygame.display.Info()
self._screen = pygame.display.set_mode((self._infoObject.current_w >> 1, self._infoObject.current_h >> 1),
pygame.HWSURFACE|pygame.DOUBLEBUF|pygame.RESIZABLE, 32)
pygame.display.set_caption("Kinect for Windows v2 Body Game")
# Loop until the user clicks the close button.
self._done = False
# Used to manage how fast the screen updates
self._clock = pygame.time.Clock()
# Kinect runtime object, we want only color and body frames
self._kinect = PyKinectRuntime.PyKinectRuntime(PyKinectV2.FrameSourceTypes_Color | PyKinectV2.FrameSourceTypes_Body)
# back buffer surface for getting Kinect color frames, 32bit color, width and height equal to the Kinect color frame size
self._frame_surface = pygame.Surface((self._kinect.color_frame_desc.Width, self._kinect.color_frame_desc.Height), 0, 32)
# here we will store skeleton data
self._bodies = None
def __init__(self):
pygame.init()
pygame.mixer.init()
self.beep_sound = pygame.mixer.Sound('audio\\beep.ogg')
self.buzz_sound = pygame.mixer.Sound('audio\\buzz.ogg')
self._infoObject = pygame.display.Info()
self._screen = pygame.display.set_mode((self._infoObject.current_w >> 1,
self._infoObject.current_h >> 1),
pygame.HWSURFACE|pygame.DOUBLEBUF|pygame.RESIZABLE, 32)
pygame.display.set_caption("Kinect Game Framework Test")
self.finished = False
self._clock = pygame.time.Clock()
self._kinect = PyKinectRuntime.PyKinectRuntime(PyKinectV2.FrameSourceTypes_Color |
PyKinectV2.FrameSourceTypes_Body)
self._frame_surface = pygame.Surface((self._kinect.color_frame_desc.Width,
self._kinect.color_frame_desc.Height), 0, 32)
self._bodies = None
self.score = 0
self.vocab_dict = {"beach":"playa", "desert":"desierto", "forest":"bosque",
"jungle":"selva", "hill":"loma", "island":"isla",
"lake":"lago", "mountain":"montaña", "ocean":"oceano",
"river":"rio", "valley":"valle", "basin":"cuenca",
"volcano":"volcano", "waterfall":"cascada", "creek":"arroyo"}
self._frame_surface.fill((255, 255, 255))
def on_resize(self, size, info):
if android is None:
# pygame.event.set_blocked(pygame.VIDEORESIZE)
repost = False
if size[0] < self.config.size_limits[0]:
size[0] = self.config.size_limits[0]
repost = True
if size[0] > self.config.size_limits[2]:
size[0] = self.config.size_limits[2]
repost = True
if size[1] < self.config.size_limits[1]:
size[1] = self.config.size_limits[1]
repost = True
if size[1] > self.config.size_limits[3]:
size[1] = self.config.size_limits[3]
repost = True
if size != self.fs_size or self.config.platform == "macos":
self.wn_size = size[:]
self.size = size[:]
self.config.settings["screenw"] = self.size[0]
self.config.settings["screenh"] = self.size[1]
self.screen = pygame.display.set_mode(self.size, pygame.RESIZABLE)
self.fs_rescale(info)
self.config.settings_changed = True
self.config.save_settings(self.db)
# pygame.event.set_allowed(pygame.VIDEORESIZE)
if repost:
pygame.event.post(
pygame.event.Event(pygame.VIDEORESIZE, size=self.size[:], w=self.size[0], h=self.size[1]))
if android is not None:
self.size = self.android_screen_size[:]
self.info.rescale_title_space()
def run(self):
self.screen = pygame.display.get_surface()
while self.running:
# Pump GTK messages.
# Pump PyGame messages.
for event in pygame.event.get():
if event.type == pygame.QUIT:
return
elif event.type == pygame.VIDEORESIZE:
pygame.display.set_mode(event.size, pygame.RESIZABLE)
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
self.currentPlayState = self.playStates.Paused
# Clear Display
self.screen.fill(self.white)
options = { 0 : self.drawMenuState,
1 : self.drawPlayState,
2 : self.drawInstructionState
}
options[self.currentPlayState]()
# Flip Display
pygame.display.flip()
# Try to stay at 30 FPS
self.clock.tick(30)
# This function is called when the game is run directly from the command line:
# ./TestGame.py
def main():
pygame.init()
pygame.display.set_mode((1200, 900), pygame.RESIZABLE)
game = BalancingAct()
game.run()
def init_screen(width, height):
global screen_size
screen_size = width, height
return pygame.display.set_mode(screen_size, pygame.RESIZABLE)
def start(self):
"""Initialize graphics."""
pygame.init()
pygame.mixer.quit()
info = pygame.display.Info()
self.width, self.height = info.current_w, info.current_h - 60
self.screen = pygame.display.set_mode(
(self.width, self.height),
pygame.RESIZABLE
)
print(os.path.dirname(os.path.realpath(__file__)))
self.surficon = pygame.image.load(ICONPATH).convert_alpha()
def resize(width, height):
length = min(width, height)
offset = int( math.fabs(width - height) / 2)
# Ugly AF
pg.display.set_mode((width, height), pg.DOUBLEBUF | pg.RESIZABLE | pg.OPENGL)
if width < height:
gl.glViewport(0, offset, length, length)
else:
gl.glViewport(offset, 0, length, length)
def create(cls, size, resizable=True):
"""
Instantiate the window at a given size.
"""
surface = Surface(size)
flag = 0
if resizable:
flag = pygame.RESIZABLE
surface._surface = pygame.display.set_mode(tuple(size), flag)
return cls(surface)
def main():
pygame.init()
pygame.display.set_mode((0, 0), pygame.RESIZABLE)
game = MathHurdler()
game.run()
def init_screen(width, height):
global temp_surface
screen = pygame.display.set_mode((width, height), pygame.RESIZABLE)
temp_surface = pygame.Surface((width / 2, height / 2)).convert()
return screen
def __init__(self, drivers=DEFAULT_DRIVERS, size=DEFAULT_SIZE, screen_type=DEFAULT_SCREEN, borders=(5, 5),
border_width=3, line_color=(255, 255, 255), font='freesans', font_color=(255, 255, 255),
icons=ICON_DICTIONARY):
"""DisplayDriver class is the class that build the base display for use in the weather
app. Argument descriptions: drivers is a tuple of strings with available SDL_VIDEODRIVER
environmental varaibles; size is a tuple of two integers describing the x, y size of the
screen; screen_type is a string value that corresponds to the pygame constants for
dispay.set_mode
"""
formats = {'no_frame': pygame.NOFRAME, 'full_screen': pygame.FULLSCREEN, 'double_buff': pygame.DOUBLEBUF,
'hw_surface': pygame.HWSURFACE, 'open_GL': pygame.OPENGL, 'resizable': pygame.RESIZABLE}
self._system_data = SystemData()
self._display_instance = None
self._drivers = drivers
self._size = size
self._borders = borders
self._border_width = border_width
self._line_color = line_color
self._font = font
self._font_color = font_color
self._format = formats[screen_type]
self._icons = icons
self._base_dir = os.getcwd() + ICON_BASE_DIR
self._scale_icons = True
self._xmax = self._size[0] - self._borders[0]
self._ymax = self._size[1] - self._borders[1]
self._av = 1
self._av_time = 1
self._screen = None
self._blits = []
def testVoronoi():
size,polygons,poly_site,river_list,city_sites,road_list,regions = setup(main_island_shape_seed=None)
pygame.init()
pygame.font.init()
city_font = pygame.font.SysFont('cardinal', 20) #cardinal
region_font = pygame.font.SysFont('cardinal', 30)
GAMEOVER = False
clock = pygame.time.Clock()
screen = pygame.display.set_mode(size,pygame.RESIZABLE)
screen.fill((255,255,255))
pygame.display.set_caption('Voronoi')
pygame.draw.rect(screen,(255,0,0),[384,320,32,32],0)
curr = Floating(384,320)
poly = polyDict = False
count = 0
first = False
pre_render(polygons,poly_site)
render_rivers(river_list)
render_roads(road_list)
bg = v_fx(screen)
while not GAMEOVER:
# --- Main event loop for event handling
action = False
for e in pygame.event.get(): # User did something
action = True
if e.type == pygame.QUIT: # If user clicked close
GAMEOVER = True
elif e.type == pygame.MOUSEBUTTONUP:
x,y = pygame.mouse.get_pos()
found = False
"""
for p in polygons:
if p.inside_polygon(x,y) and not found:
pts = [i.get_cords() for i in p.vertices]
pygame.draw.polygon(screen,(40,40,40),pts)
found = True
else:
p.draw()
"""
if action:
for p in polygons:
p.draw()
render_rivers(river_list)
render_roads(road_list)
render_cities(city_sites,city_font)
render_regions(regions,region_font)
pygame.display.update()
#print(pygame.image.tostring(screen,"RGB"))
# --- Limit to 5 frames per second
clock.tick(5)
if not polyDict:
polyDict = not polyDict
pygame.quit()
def todo_test_set_mode(self):
# __doc__ (as of 2008-08-02) for pygame.display.set_mode:
# pygame.display.set_mode(resolution=(0,0), flags=0, depth=0): return Surface
# initialize a window or screen for display
#
# This function will create a display Surface. The arguments passed in
# are requests for a display type. The actual created display will be
# the best possible match supported by the system.
#
# The resolution argument is a pair of numbers representing the width
# and height. The flags argument is a collection of additional
# options. The depth argument represents the number of bits to use
# for color.
#
# The Surface that gets returned can be drawn to like a regular
# Surface but changes will eventually be seen on the monitor.
#
# If no resolution is passed or is set to (0, 0) and pygame uses SDL
# version 1.2.10 or above, the created Surface will have the same size
# as the current screen resolution. If only the width or height are
# set to 0, the Surface will have the same width or height as the
# screen resolution. Using a SDL version prior to 1.2.10 will raise an
# exception.
#
# It is usually best to not pass the depth argument. It will default
# to the best and fastest color depth for the system. If your game
# requires a specific color format you can control the depth with this
# argument. Pygame will emulate an unavailable color depth which can
# be slow.
#
# When requesting fullscreen display modes, sometimes an exact match
# for the requested resolution cannot be made. In these situations
# pygame will select the closest compatable match. The returned
# surface will still always match the requested resolution.
#
# The flags argument controls which type of display you want. There
# are several to choose from, and you can even combine multiple types
# using the bitwise or operator, (the pipe "|" character). If you pass
# 0 or no flags argument it will default to a software driven window.
# Here are the display flags you will want to choose from:
#
# pygame.FULLSCREEN create a fullscreen display
# pygame.DOUBLEBUF recommended for HWSURFACE or OPENGL
# pygame.HWSURFACE hardware accelerated, only in FULLSCREEN
# pygame.OPENGL create an opengl renderable display
# pygame.RESIZABLE display window should be sizeable
# pygame.NOFRAME display window will have no border or controls
self.fail()
def run(self):
# -------- Main Program Loop -----------
while not self._done:
# --- Main event loop
for event in pygame.event.get(): # User did something
if event.type == pygame.QUIT: # If user clicked close
self._done = True # Flag that we are done so we exit this loop
elif event.type == pygame.VIDEORESIZE: # window resized
self._screen = pygame.display.set_mode(event.dict['size'],
pygame.HWSURFACE|pygame.DOUBLEBUF|pygame.RESIZABLE, 32)
# --- Game logic should go here
# --- Getting frames and drawing
# --- Woohoo! We've got a color frame! Let's fill out back buffer surface with frame's data
if self._kinect.has_new_color_frame():
frame = self._kinect.get_last_color_frame()
self.draw_color_frame(frame, self._frame_surface)
frame = None
# --- Cool! We have a body frame, so can get skeletons
if self._kinect.has_new_body_frame():
self._bodies = self._kinect.get_last_body_frame()
# --- draw skeletons to _frame_surface
if self._bodies is not None:
for i in range(0, self._kinect.max_body_count):
body = self._bodies.bodies[i]
if not body.is_tracked:
continue
joints = body.joints
# convert joint coordinates to color space
joint_points = self._kinect.body_joints_to_color_space(joints)
self.draw_body(joints, joint_points, SKELETON_COLORS[i])
# --- copy back buffer surface pixels to the screen, resize it if needed and keep aspect ratio
# --- (screen size may be different from Kinect's color frame size)
h_to_w = float(self._frame_surface.get_height()) / self._frame_surface.get_width()
target_height = int(h_to_w * self._screen.get_width())
surface_to_draw = pygame.transform.scale(self._frame_surface, (self._screen.get_width(), target_height));
self._screen.blit(surface_to_draw, (0,0))
surface_to_draw = None
pygame.display.update()
# --- Go ahead and update the screen with what we've drawn.
pygame.display.flip()
# --- Limit to 60 frames per second
self._clock.tick(60)
# Close our Kinect sensor, close the window and quit.
self._kinect.close()
pygame.quit()
def todo_test_set_mode(self):
# __doc__ (as of 2008-08-02) for pygame.display.set_mode:
# pygame.display.set_mode(resolution=(0,0), flags=0, depth=0): return Surface
# initialize a window or screen for display
#
# This function will create a display Surface. The arguments passed in
# are requests for a display type. The actual created display will be
# the best possible match supported by the system.
#
# The resolution argument is a pair of numbers representing the width
# and height. The flags argument is a collection of additional
# options. The depth argument represents the number of bits to use
# for color.
#
# The Surface that gets returned can be drawn to like a regular
# Surface but changes will eventually be seen on the monitor.
#
# If no resolution is passed or is set to (0, 0) and pygame uses SDL
# version 1.2.10 or above, the created Surface will have the same size
# as the current screen resolution. If only the width or height are
# set to 0, the Surface will have the same width or height as the
# screen resolution. Using a SDL version prior to 1.2.10 will raise an
# exception.
#
# It is usually best to not pass the depth argument. It will default
# to the best and fastest color depth for the system. If your game
# requires a specific color format you can control the depth with this
# argument. Pygame will emulate an unavailable color depth which can
# be slow.
#
# When requesting fullscreen display modes, sometimes an exact match
# for the requested resolution cannot be made. In these situations
# pygame will select the closest compatable match. The returned
# surface will still always match the requested resolution.
#
# The flags argument controls which type of display you want. There
# are several to choose from, and you can even combine multiple types
# using the bitwise or operator, (the pipe "|" character). If you pass
# 0 or no flags argument it will default to a software driven window.
# Here are the display flags you will want to choose from:
#
# pygame.FULLSCREEN create a fullscreen display
# pygame.DOUBLEBUF recommended for HWSURFACE or OPENGL
# pygame.HWSURFACE hardware accelerated, only in FULLSCREEN
# pygame.OPENGL create an opengl renderable display
# pygame.RESIZABLE display window should be sizeable
# pygame.NOFRAME display window will have no border or controls
self.fail()
def show(Runner, arg=None, fps=24, rows=17, cols=165, scale=8, withArgs=False):
import pygame, sys
FPS = fps
fpsClock = pygame.time.Clock()
board_dimensions = (cols, rows)
#yep
disp_size = (cols * scale, rows * scale)
pygame.init()
screen_opts = pygame.RESIZABLE | pygame.DOUBLEBUF
screen = pygame.display.set_mode(disp_size, screen_opts)
changed = False
if arg is None:
runner = Runner(board_dimensions)
else:
runner = Runner(board_dimensions, arg)
font = pygame.font.Font('slkscr.ttf', 32)
while True:
events = pygame.event.get()
for e in events:
if e.type == pygame.QUIT:
sys.exit()
if e.type == pygame.VIDEORESIZE:
disp_size = e.dict['size']
screen = pygame.display.set_mode(disp_size, screen_opts)
screen.fill((0, 0, 0))
# draw the pixels
txts = ["FPS: {0:.2f}".format(fpsClock.get_fps())]
if withArgs:
pixels, txt = runner.run(events)
txts.append(txt)
else:
pixels = runner.run()
if type(pixels) is tuple:
pixels, txt = pixels
txts.append(txt)
temp_surface = pygame.Surface(board_dimensions)
pygame.surfarray.blit_array(temp_surface, pixels)
pygame.transform.scale(temp_surface, disp_size, screen)
i = 1
for txt in txts:
for line in txt.splitlines():
screen.blit(font.render(line.replace('[', '').replace(']', '').strip(), 1, (255, 255, 255)),
(30, 30 * i))
i += 1
pygame.display.flip()
fpsClock.tick(FPS)
def __init__(self, host, port,camtype="webcam",ID=0,image_name='lena.png',change=True,Debug=True):
self.host = host
self.port = port
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sock.bind((self.host, self.port))
self.comThreads = []
self.alive = True;
self.RGB0 = [];
self.Depth = [];
self.Body = [];
self.camtype = camtype;
self.ret = False;
self.log = "test"
self.HDRGB = [];
self.imageName = image_name;
self.change = change;
self.sys_random = random.SystemRandom();
#Assuming 8bit pic
self.cnt = 0;
self.trip = 0;
self.Debug = Debug
self.send_counter = 0;
self.rgb_cnt = 0;
#Locks
self.Lock = threading.Lock()
if self.Debug:
self.img = cv2.imread(self.imageName); #This one will be altered!
self.orig_img = cv2.imread(self.imageName); #This one will be the same
self.ImageT = threading.Thread(target=self.imagechanger)
self.ImageT.start()
self.height,self.width,self.channel = self.img.shape;
self.x_pos = random.randint(10,self.width);
self.y_pos = random.randint(10,self.height);
if self.ImageT.isAlive():
self.log = "height: " + str(self.height)
if Kinect:
pygame.init()
#Used to manage how fast the screen updates
self._clock = pygame.time.Clock()
self._done = False;
self._infoObject = pygame.display.Info()
self._screen = pygame.display.set_mode((self._infoObject.current_w >> 1, self._infoObject.current_h >> 1),
pygame.HWSURFACE|pygame.DOUBLEBUF|pygame.RESIZABLE, 32)
# Kinect runtime object, we want only color and body frames
self._kinect = PyKinectRuntime.PyKinectRuntime(PyKinectV2.FrameSourceTypes_Color | PyKinectV2.FrameSourceTypes_Body | PyKinectV2.FrameSourceTypes_Depth | PyKinectV2.FrameSourceTypes_Infrared)
# back buffer surface for getting Kinect color frames, 32bit color, width and height equal to the Kinect color frame size
self._frame_surface = pygame.Surface((self._kinect.color_frame_desc.Width, self._kinect.color_frame_desc.Height), 0, 32)
# here we will store skeleton data
self._bodies = None
if camtype == "webcam":
self.cap = cv2.VideoCapture(ID)
def __init__(self):
pygame.init()
# Used to manage how fast the screen updates
self._clock = pygame.time.Clock()
# Set the width and height of the screen [width, height]
self._infoObject = pygame.display.Info()
self._screen = pygame.display.set_mode(
(self._infoObject.current_w >> 1, self._infoObject.current_h >> 1),
pygame.HWSURFACE | pygame.DOUBLEBUF | pygame.RESIZABLE, 32
)
pygame.display.set_caption("Guess your Age!")
# Loop until the user clicks the close button.
self._done = False
# Kinect runtime object, we want only color and body frames
if PyKinectRuntime and USE_KINECT:
self._kinect = PyKinectRuntime.PyKinectRuntime(
PyKV2.FrameSourceTypes_Color |
PyKV2.FrameSourceTypes_Body
)
frame_dimension = (
self._kinect.color_frame_desc.Width,
self._kinect.color_frame_desc.Height
)
else:
self._kinect = None
frame_dimension = 800, 600
# back buffer surface for getting Kinect color frames, 32bit color,
# width and height equal to the Kinect color frame size
self._frame_surface = pygame.Surface(frame_dimension, 0, 32)
# here we will store skeleton data
self._bodies = None
self._stored_bodies = {}
self._faces = []
self._face_bodies = []
self._update_oxford = 0
self.python_logo_image = pygame.image.load('pylogo.png')
self.msft_logo_image = pygame.image.load('microsoftlogo.png')
self.bg_color = pygame.Color(55, 117, 169)
