def __init__(self, big, location, direction, *groups):
self.type = 'turkeyshake'
pygame.sprite.Sprite.__init__( self, *groups )
self.movement = { 'up':0, 'down':0, 'left':0, 'right':0 }
if big == True:
self.image = util.load_image( "smoothie_TurkeyBig.png" )
else:
self.image = util.load_image( "smoothie_Turkey.png" )
self.rect = self.image.get_rect()
self.time = 30
self.exploded = False
self.big = big
if pygame.mixer.get_init():
self.sound = pygame.mixer.Sound(pkg_resources.resource_stream("applesauce", "sounds/Slurping Smoothie.ogg"))
self.sound.set_volume(0.8)
self.sound.play()
else:
self.sound = None
if direction.endswith( 'up' ):
self.movement['up'] = 1
elif direction.endswith( 'down' ):
self.movement['down'] = 1
if direction.startswith( 'left' ):
self.movement['left'] = 1
elif direction.startswith( 'right' ):
self.movement['right'] = 1
if self.movement['up'] ^ self.movement['down'] == 1 and self.movement['left'] ^ self.movement['right'] == 1:
self.speed = math.sqrt( 50 )
else:
self.speed = 10
self.rect.center = location
def refresh_image(self):
super(DockingRing, self).refresh_image()
if self.open:
self.sprite.add_layer('DockingRing',util.load_image("images/open_hatch.png"))
else:
self.sprite.add_layer('DockingRing',util.load_image("images/closed_hatch.png"))
self.sprite.layer['Equipment'].visible=False
def __getitem__(self, index):
albedo = load_image(join(self.albedo_path,'albedo-'+ self.image_filenames[index]))
depth = load_image(join(self.depth_path, 'depth-'+self.image_filenames[index]))
direct = load_image(join(self.direct_path,'direct-'+ self.image_filenames[index]))
normal = load_image(join(self.normal_path, 'normals-'+self.image_filenames[index]))
gt = load_image(join(self.gt_path, 'output-'+self.image_filenames[index]))
return albedo, direct, normal, depth, gt
def refresh_image(self):
super(WaterTank, self).refresh_image()
if self.sprite is None: return
if 'Gray Water' in self.filter.target:
self.sprite.add_layer('GrayDrop',util.load_image("images/graywdrop_40x40.png"))
else:
self.sprite.add_layer('WaterDrop',util.load_image("images/waterdrop_40x40.png"))
def __init__(self, big, location, constraint, flyers, bombs, boomboxes, turkeyshakes, *groups):
if big == True:
effects.SpriteSheet.__init__(self, util.load_image( "playerBigMove_sheet.png" ), (60,90) )
self.max_speed = 5
else:
effects.SpriteSheet.__init__(self, util.load_image( "playerMove_sheet.png" ), (30,45) )
self.max_speed = 4
self.constraint = constraint
self.movement = { 'up':0, 'down':0, 'left':0, 'right':0 }
self.facing = 'right'
self.flyers = flyers
self.bombs = bombs
self.boomboxes = boomboxes
self.turkeyshakes = turkeyshakes
self.contacting = ''
self.time = 0
self.anim_frame = 0
self.state = 0
self.flipped = False
self.booltop = True
self.wait = 0
self.bomb_place = False
self.placing = 0
self.end = False
self.rect.center = location
if big:
self.rect.height -= 45
else:
self.rect.height -= 22.5
def convert_lrgb_to_srgb(directory, gamma=2.0):
with open(os.path.join(directory, "whitepoint_matrices.json")) as f:
matrices = json.load(f)
def transform(image, matrix):
return (matrix @ image.reshape(-1, 3).T).T.reshape(image.shape)
for index in range(1, 28):
print("image", index, "of", 27)
path = os.path.join(directory,
"input_with_gt_fgd/input/GT%02d.tif" % index)
lrgb = util.load_image(path)
lrgb = transform(lrgb, np.float64(matrices[str(index)]).reshape(3, 3))
lrgb = np.maximum(0, lrgb)
srgb = util.lrgb_to_srgb(lrgb, gamma)
srgb = np.clip(srgb, 0, 1)
image = srgb
path = os.path.join(directory,
"input_with_gt_fgd/fgd/GT%02d.tif" % index)
lrgb = util.load_image(path)
lrgb = transform(lrgb, np.float64(matrices[str(index)]).reshape(3, 3))
lrgb = np.maximum(0, lrgb)
srgb = util.lrgb_to_srgb(lrgb, gamma)
srgb = np.clip(srgb, 0, 1)
foreground = srgb
path = os.path.join(directory, "converted/image/GT%02d.bmp" % index)
util.save_image(path, image)
path = os.path.join(directory,
"converted/foreground/GT%02d.bmp" % index)
util.save_image(path, foreground)
def __init__(self, ship_rect, ship_angle, left=False, special=False):
pygame.sprite.Sprite.__init__(self)
if not Cannonball.image:
Cannonball.image = util.load_image("kuti")
if not Cannonball.spec_image:
Cannonball.spec_image = pygame.transform.flip(
util.load_image("lokki2"), 1, 0)
if not Cannonball.sound:
Cannonball.sound = util.load_sound("pam")
screen = pygame.display.get_surface()
self.area = screen.get_rect()
if special:
self.image = Cannonball.spec_image
else:
self.image = Cannonball.image
self.special = special
self.underwater = 0
#self.hitmask = pygame.surfarray.array_alpha(self.image)
if (Variables.sound):
Cannonball.sound.play()
#self.dy = -5
#self.dx = 10
# Shoot at an angle of 25 relative to the ship
self.angle = 0
if not left:
if special:
velocity = 14.0
self.rect = pygame.Rect(ship_rect.right, ship_rect.top,
self.image.get_width(),
self.image.get_height())
self.vect = [
math.cos(
(-ship_angle - 15.0) / 180.0 * math.pi) * velocity,
math.sin((-ship_angle - 15.0) / 180.0 * math.pi) * velocity
]
else:
velocity = 11.0
self.rect = pygame.Rect(ship_rect.right, ship_rect.centery,
self.image.get_width(),
self.image.get_height())
self.vect = [
math.cos((-ship_angle - 25.0) / 180.0 * math.pi) * velocity,
math.sin((-ship_angle - 25.0) / 180.0 * math.pi) * velocity
]
else:
self.rect = pygame.Rect(ship_rect.left, ship_rect.centery,
self.image.get_width(),
self.image.get_height())
self.vect = [
math.cos(
(-ship_angle + 180.0 + 25.0) / 180.0 * math.pi) * 11.0,
math.sin((-ship_angle + 180.0 + 25.0) / 180.0 * math.pi) * 11.0
]
def __init__(self,context, direction=-1):
self.image,self.rect = load_image( 'ground.png',-1,-1,-1)
self.image1,self.rect1 = load_image( 'ground.png',-1,-1,-1)
self.rect.bottom = context.height
self.rect1.bottom = context.height
self.rect1.left = self.rect.right
self.context = context
self.direction = direction
def __init__(self, x, y):
image_on = util.load_image('images/ship2-on.png')
image_off = util.load_image('images/ship2-off.png')
self.sprite_on = pyglet.sprite.Sprite(image_on, x=x, y=y, batch=batch, group=ships)
self.sprite_off = pyglet.sprite.Sprite(image_off, x=x, y=y, batch=batch, group=ships)
self.sprite = self.sprite_off
self.body = physics.Body(x, y, 12, fixed=False)
self.fuel_usage = 0
def __load__(self, index):
left_img_path = self.json_data[index]["imageL"]
right_img_path = self.json_data[index]["imageR"]
output_img_path = self.json_data[index]["output"]
left_img = load_image(left_img_path)
right_img = load_image(right_img_path)
return left_img, right_img, output_img_path
def init():
Health.heart = util.load_image("sydan")
Health.heart_empty = util.load_image("sydan-tyhja")
Health.heart_broken = util.load_image("sydan-rikki")
heart_broken = pygame.Surface((Health.heart_broken.get_rect().width, Health.heart_broken.get_rect().height))
heart_broken.fill((255,0,255))
heart_broken.set_colorkey((255,0,255))
heart_broken.blit(Health.heart_broken, heart_broken.get_rect())
Health.heart_broken = heart_broken
def init():
Health.heart = util.load_image("sydan")
Health.heart_empty = util.load_image("sydan-tyhja")
Health.heart_broken = util.load_image("sydan-rikki")
heart_broken = pygame.Surface((Health.heart_broken.get_rect().width, Health.heart_broken.get_rect().height))
heart_broken.fill((255,0,255))
heart_broken.set_colorkey((255,0,255))
heart_broken.blit(Health.heart_broken, heart_broken.get_rect())
Health.heart_broken = heart_broken
def test_conversion(conversion):
for i in range(1, 5):
lr_orig = np.array(load_image(lr(IMG_PATH, i, 'png')))
hr_orig = np.array(load_image(hr(IMG_PATH, i, 'png')))
lr_conv = np.load(lr(ARR_PATH, i, 'npy'))
hr_conv = np.load(hr(ARR_PATH, i, 'npy'))
assert np.array_equal(lr_orig, lr_conv)
assert np.array_equal(hr_orig, hr_conv)
def refresh_image(self):
super(Machinery, self).refresh_image()
if self.sprite is None: return
import pyglet
img1=pyglet.image.AnimationFrame(util.load_image("images/machinery_40x40.png"),0.5 if self.active else None)
img2=pyglet.image.AnimationFrame(util.load_image("images/machinery_40x40_1.png"),0.5)
animation = pyglet.image.Animation([img1,img2])
self.sprite.add_layer('Machinery',animation)
def __init__(self, result):
pygame.sprite.Sprite.__init__(self)
if result == WIN:
self.image, self.rect = load_image("prompt_win.png")
elif result == DRAW:
self.image, self.rect = load_image("prompt_draw.png")
elif result == LOSE:
self.image, self.rect = load_image("prompt_lose.png")
else:
raise "Not valid result!"
def __init__(self, img_address, img_address_clicked, topleft_x, topleft_y,
state):
self.x = topleft_x
self.y = topleft_y
self.hovered = False
self.img = load_image(img_address)
self.img_hovered = load_image(img_address_clicked)
self.rect = self.img.get_rect(topleft=(topleft_x, topleft_y))
self.rect_hovered = self.img_hovered.get_rect(topleft=(topleft_x,
topleft_y))
self.state = state
def __init__(self, window: Window):
super().__init__(window)
from constants import BUTTON_SIZE
self.window_size = window.get_size()
self.window_center = (self.window_size[0] / 2, self.window_size[1] / 2)
dpi_factor = window.hidpi_factor
button_size = (BUTTON_SIZE[0] * dpi_factor,
BUTTON_SIZE[1] * dpi_factor)
button_font = Font('sans-serif', 16, dpi_factor)
self.bg_image = util.load_image('assets/background.png')
self.bg_size = (self.bg_image.get_width(), self.bg_image.get_height())
self.bg_center = (self.bg_size[0] / 2, self.bg_size[1] / 2)
self.logo = util.load_image('assets/logo.png')
self.logo_size = (self.logo.get_width(), self.logo.get_height())
self.logo_center = (self.logo_size[0] / 2, self.logo_size[1] / 2)
self.max_score = 0
self.last_active_level = None
self.text_font = Font('monospace', 20, window.hidpi_factor)
self.text_font_color = Color(255, 255, 255)
# Template to create new button
start_btn = Button(window,
'[ Start ]',
Vector(self.window_center[0] - button_size[0] / 2,
self.window_center[1] - button_size[1]),
Vector(*button_size),
Color(0, 102, 255),
Color(255, 255, 255),
Color(0, 80, 230),
Color(255, 255, 255),
font=button_font)
start_btn.set_click_handler(self.start)
self.children.append(start_btn)
help_btn = Button(window,
'[ Help ]',
Vector(self.window_center[0] - button_size[0] / 2,
self.window_center[1] + button_size[1]),
Vector(*button_size),
Color(0, 102, 255),
Color(255, 255, 255),
Color(0, 80, 230),
Color(255, 255, 255),
font=button_font)
help_btn.set_click_handler(self.help)
self.children.append(help_btn)
def __init__(self, name, group=None):
self.name = name
info_path = util.respath('environments', name, 'info.json')
with pyglet.resource.file(info_path, 'r') as info_file:
info = json.load(info_file)
self.background_tile_rows = info['tile_rows']
self.background_tile_cols = info['tile_columns']
self.background_batch = pyglet.graphics.Batch()
self.background_sprites = []
self.overlay_batch = pyglet.graphics.Batch()
self.overlay_sprites = []
self.width = 0
self.height = 0
background_sprites_dict = {}
tile_w = 0
tile_h = 0
for x in range(self.background_tile_cols):
this_y = 0
for y in range(self.background_tile_rows):
img = util.load_image(
util.respath('environments', name, '%d_%d.png' % (x, y)))
tile_w, tile_h = img.width, img.height
new_sprite = pyglet.sprite.Sprite(img,
x=x * tile_w,
y=y * tile_h,
batch=self.background_batch,
group=group)
self.background_sprites.append(new_sprite)
background_sprites_dict[(x, y)] = new_sprite
for x in range(self.background_tile_cols):
self.width += background_sprites_dict[(x, 0)].width
for y in range(self.background_tile_rows):
self.height += background_sprites_dict[(0, y)].height
gamestate.camera_max = (self.width - gamestate.norm_w // 2,
self.height - gamestate.norm_h // 2)
for x in range(self.background_tile_cols):
for y in range(self.background_tile_rows):
overlay_tile_path = util.respath('environments', name,
'overlay_%d_%d.png' % (x, y))
try:
img = util.load_image(overlay_tile_path)
new_sprite = pyglet.sprite.Sprite(img,
x=x * tile_w,
y=y * tile_h,
batch=self.overlay_batch)
self.overlay_sprites.append(new_sprite)
except pyglet.resource.ResourceNotFoundException:
pass # Ignore if no overlay
self.draw = self.background_batch.draw
self.draw_overlay = self.overlay_batch.draw
self.behind = util.load_image('environments/spacebackground.png')
def test_img_save_and_load(self):
test_img = util.load_image(test_img_dir / '2.png', size=64)
self.assertEqual(type(test_img), np.ndarray)
self.assertEqual(test_img.shape, (64, 64, 3))
self.assertEqual(test_img.dtype, np.float64)
util.save_image(test_img_dir / 'test.png', test_img)
file = (test_img_dir / 'test.png')
self.assertTrue(file.exists())
self.assertTrue(file.is_file())
self.assertTrue(np.allclose(test_img, util.load_image(file)))
file.unlink()
def get_tile(self, name, colorkey=None, tile_pos=None):
key = (name, tile_pos)
if not self.tiles.has_key( key ):
image = util.load_image(TILES_DIR, name)
image = util.load_image(TILES_DIR, name).convert()
if tile_pos is not None:
tmp = Surface( (TILE_SIZE, TILE_SIZE) )
rect = Rect(tile_pos[0]*TILE_SIZE, tile_pos[1]*TILE_SIZE,TILE_SIZE,TILE_SIZE)
tmp.blit(image, (0,0), rect)
image = tmp.convert()
self.tiles[key] = image
return self.tiles[key]
def __load__(self, index):
left_img_path = os.path.join(self.dataset_root, self.json_data[index]["imageL"])
right_img_path = os.path.join(self.dataset_root, self.json_data[index]["imageR"])
left_normal_path = os.path.join(self.dataset_root, self.json_data[index]["normalL"])
right_normal_path = os.path.join(self.dataset_root, self.json_data[index]["normalR"])
left_img = load_image(left_img_path)
right_img = load_image(right_img_path)
left_normal = load_normal(left_normal_path)
right_normal = load_normal(right_normal_path)
return left_img, right_img, left_normal, right_normal
def __init__(self,pos,offset = 16):
#load imgs
self._default = util.load_image("data/bw_key0.png")
self._red = util.load_image("data/red_key0.png")
self._green = util.load_image("data/green_key0.png")
self._blue = util.load_image("data/blue_key0.png")
self.red = self._default
self.green = self._default
self.blue = self._default
self.offset = offset
self.draw_pos = pos
def explode(self):
if self.exploded == False:
self.time = 200
self.exploded = True
if self.big == True:
self.image = util.load_image( "hit_smoothie_TurkeyBig.png" )
else:
self.image = util.load_image( "hit_smoothie_Turkey.png" )
tmp = self.image.get_rect()
tmp.center = self.rect.center
self.rect = tmp
for value in self.movement.keys():
self.movement[value] = 0
def main():
p = argparse.ArgumentParser(
description=
'Given two images and some kernels, report the difference per kernel.')
p.add_argument('a', help='input image filename')
p.add_argument('b', help='expected image filename')
p.add_argument('kernels', nargs='*', help='kernel directory')
p.add_argument(
'-gamma',
type=float,
default=1.0,
help='gamma correction to use for images (default: no correction)')
p.add_argument('-crop_x',
type=int,
default=0,
help='crop X offset in pixels, range is [0..width-1]')
p.add_argument(
'-crop_y',
type=int,
default=0,
help=
'crop Y offset in pixels, range is [0..height-1] where 0 is the TOP')
p.add_argument('-crop_w', type=int, default=0, help='crop width in pixels')
p.add_argument('-crop_h',
type=int,
default=0,
help='crop height in pixels')
args = p.parse_args()
img1 = util.load_image(args.a, args)
img2 = util.load_image(args.b, args)
assert img1.shape == img2.shape, (img1.shape, img2.shape)
print('# Loaded images. Shape is', img1.shape)
img_input = tf.constant(img1)
img_expected = tf.constant(img2)
sess = util.make_session()
for kfn in args.kernels:
step, kernel = util.load_kernel(kfn)
n = kernel.shape[0]
border = (n + 1) // 2
# Convolve and calculate costs.
img_actual = util.convolve(img_input, kernel)
dcost = sess.run(
util.diff_cost(util.diff(img_actual, img_expected, border)))
rcost = sess.run(util.reg_cost(kernel))
print(kfn, 'n', n, 'diffcost %.12f' % dcost, 'regcost', rcost,
'avg-px-err', util.avg_px_err(dcost, args.gamma))
def __init__(self, name, group=None):
self.name = name
info_path = util.respath('environments', name, 'info.json')
with pyglet.resource.file(info_path, 'r') as info_file:
info = json.load(info_file)
self.background_tile_rows = info['tile_rows']
self.background_tile_cols = info['tile_columns']
self.background_batch = pyglet.graphics.Batch()
self.background_sprites = []
self.overlay_batch = pyglet.graphics.Batch()
self.overlay_sprites = []
self.width = 0
self.height = 0
background_sprites_dict = {}
tile_w = 0
tile_h = 0
for x in range(self.background_tile_cols):
this_y = 0
for y in range(self.background_tile_rows):
img = util.load_image(util.respath('environments',
name,
'%d_%d.png' % (x, y)))
tile_w, tile_h = img.width, img.height
new_sprite = pyglet.sprite.Sprite(img, x=x*tile_w, y=y*tile_h,
batch=self.background_batch,
group=group)
self.background_sprites.append(new_sprite)
background_sprites_dict[(x, y)] = new_sprite
for x in range(self.background_tile_cols):
self.width += background_sprites_dict[(x, 0)].width
for y in range(self.background_tile_rows):
self.height += background_sprites_dict[(0, y)].height
gamestate.camera_max = (self.width-gamestate.norm_w//2, self.height-gamestate.norm_h//2)
for x in range(self.background_tile_cols):
for y in range(self.background_tile_rows):
overlay_tile_path = util.respath('environments', name, 'overlay_%d_%d.png' % (x, y))
try:
img = util.load_image(overlay_tile_path)
new_sprite = pyglet.sprite.Sprite(img, x=x*tile_w, y=y*tile_h,
batch=self.overlay_batch)
self.overlay_sprites.append(new_sprite)
except pyglet.resource.ResourceNotFoundException:
pass # Ignore if no overlay
self.draw = self.background_batch.draw
self.draw_overlay = self.overlay_batch.draw
self.behind = util.load_image('environments/spacebackground.png')
def __init__(self, pos, image, space, anim_name="", num_frames=1, sequence=[0, 1], frequency=8):
self.is_movable = True
GameObject.__init__(
self, pos, util.to_sprite(util.load_image("data/info_sign0.png")), space, OBJECT_TYPE_INFO, pm.inf
)
self.body, self.shape = create_box(space, (pos.x, pos.y), frequency, 12.0)
self.shape.collision_type = OBJECT_TYPE_INFO
self.info_bubble = util.load_image(image)
space.add_static(self.shape)
self._show_info = False
self.cool_down = 0.0
if not anim_name == "":
self.animation = animation.new_animation(anim_name, "png", num_frames, frequency, sequence)
self.animation.play()
def process(params):
# unpack arguments (needed for multiprocessing)
filename, args = params
if args.out:
outname = join_out_filename(args.out, os.path.basename(filename))
else:
outname = compute_out_filename(filename)
print("Processing", filename, "=>", outname)
array, info = load_image(filename)
restored_image = restore(array, args)
if info:
# transfer exif info
try:
import piexif
except ImportError:
warnings.warn("Python module 'piexif' is required in order to preserve EXIF information.")
exif_bytes = b''
else:
exif_dict = piexif.load(info['exif'])
# remove thumbnail from exif info (new appearance)
del exif_dict['thumbnail']
exif_bytes = piexif.dump(exif_dict)
else:
exif_bytes = b''
save_image(outname, restored_image, quality=args.quality, exif=exif_bytes)
def refresh_image(self):
super(SolarPanel, self).refresh_image()
if self.sprite is None: return
img = util.load_image("images/solarpanel_horiz.png")
img.anchor_x, img.anchor_y = [2,15]
self.sprite.add_layer('SolarPanel',img)
self.sprite.layer['Equipment'].visible=False
def __init__(self, ship_rect, ship_angle, left = False):
pygame.sprite.Sprite.__init__(self)
if not Cannonball.image:
Cannonball.image = util.load_image("kuti")
if not Cannonball.sound:
Cannonball.sound = util.load_sound("pam")
screen = pygame.display.get_surface()
self.area = screen.get_rect()
self.image = Cannonball.image
self.hitmask = pygame.surfarray.array_alpha(self.image)
Cannonball.sound.play()
#self.dy = -5
#self.dx = 10
# Shoot at an angle of 25 relative to the ship
if not left:
self.rect = pygame.Rect(ship_rect.right, ship_rect.centery, self.image.get_width(), self.image.get_height())
self.vect = [math.cos((-ship_angle - 25.0) / 180.0 * math.pi) * 11.0,
math.sin((-ship_angle - 25.0) / 180.0 * math.pi) * 11.0]
else:
self.rect = pygame.Rect(ship_rect.left, ship_rect.centery, self.image.get_width(), self.image.get_height())
self.vect = [math.cos((-ship_angle + 180.0 + 25.0) / 180.0 * math.pi) * 11.0,
math.sin((-ship_angle + 180.0 + 25.0) / 180.0 * math.pi) * 11.0]
def __init__(self, usealpha):
pygame.sprite.Sprite.__init__(self)
self.image = pygame.Surface((SCREEN_WIDTH, SCREEN_HEIGHT))
self.rect = self.image.get_rect()
if not Water.raster_image:
Water.raster_image = util.load_image("rasteri")
self.water_levels = []
for i in range(self.rect.width):
self.water_levels.append(0.0)
self.t = 0
self.usealpha = usealpha
self.target_amplitude = self.amplitude = SCREEN_HEIGHT / 8.0
self.target_wavelength = self.wavelength = 0.02 * SCREEN_WIDTH / 2.0 / math.pi
self.target_speed = self.speed = 0.06 / math.pi / 2.0 * FPS
self.target_baseheight = self.baseheight = SCREEN_HEIGHT / 24.0 * 8.0
if self.usealpha:
self.image.set_alpha(110)
self.update()
def __init__(self, image_path, shape):
self.image_path = image_path
self.image = load_image(image_path, shape)
self.height = self.image.shape[0]
self.width = self.image.shape[1]
self.num_channels = self.image.shape[2]
def refresh_image(self, imgfile, x_off = 0):
if self.sprite: self.sprite.delete()
import graphics_pyglet
self.sprite = graphics_pyglet.LayeredSprite(name=self.name,start_order = -30)
img = util.load_image(imgfile )
self.sprite.add_layer(self.name,img)
self.sprite._offset = [gv.config['ZOOM'] * 2 * x_off, 0]
def __create__(self, file, name, size):
# Open the generation Image:
temp_file = util.load_image(file, util.config.settings['Screen_Size'])
# Create new Folder
self.name = name
this_path = util.local_path('source/Maps', self.name)
if os.path.exists( this_path ): return -1
os.makedirs( this_path )
os.makedirs( this_path + '/items')
# Save Background
temp_file.save( this_path + '/background.gif' )
temp_file.close()
# Write Config
temp_file = open( this_path + '/config', 'w')
## Write Dimensions
temp_file.write("%d, %d\n\n" % (size[0], size[1]))
## Write wall positions
for i in range(size[1]):
temp_file.write((' 0,' * size[0])[1:-1] + '\n')
temp_file.write('\n')
## Write Object Start positions
for i in range(size[1]):
temp_file.write((' 0,' * size[0])[1:-1] + '\n')
temp_file.write('\n')
## Write Object Defenitions: None
## Close config file and load from created files.
temp_file.close()
self.__load__()
def __init__(self, posX):
pygame.sprite.Sprite.__init__(self)
self.image = util.load_image("images/pala.png")
self.rect = self.image.get_rect()
self.rect.centerx = posX
self.rect.centery = util.HEIGHT / 2
self.speed = 0.4
def main():
p = argparse.ArgumentParser(description='Convolve an image with a kernel.')
p.add_argument('img', help='input image filename')
p.add_argument('k', help='path to kernel ')
p.add_argument(
'-gamma',
type=float,
default=1.0,
help='gamma correction to use for images (default: no correction)')
p.add_argument('-out', help='output to *.png file instead of viewing')
args = p.parse_args()
img = util.load_image(args.img, args, gray=False)
n, h, w, c = img.shape
assert n == 1, n
out = np.zeros((h, w, c), dtype=np.float32)
step, kernel = util.load_kernel(args.k)
sess = util.make_session()
for i in range(c):
chan = sess.run(
util.convolve(tf.constant(img[:, :, :, i:i + 1]), kernel))
out[:, :, i] = chan[0, :, :, 0]
out = util.from_float(out, args.gamma)
if args.out is not None:
util.save_image(args.out, out)
print('Written to', args.out)
else:
print('Press ESC to close window.')
util.viewer(None, lambda: out)
def show_pose(dataset_model, dataset_image, base_dir, outputs, list_file,
save_dir, is_flip, gif):
if list_file is None:
names = util.load_names(dataset_image)
else:
with open(list_file) as f:
names = [line.strip() for line in f]
assert len(names) == outputs.shape[0]
for idx, (name, pose) in enumerate(zip(names, outputs)):
img = util.load_image(dataset_image,
os.path.join(base_dir, name),
is_flip=is_flip)
img = img.astype(np.float32)
img = (img - img.min()) / (img.max() - img.min()) * 255
img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
img = util.draw_pose(dataset_model, img, pose)
cv2.imshow('result', img / 255)
if save_dir is not None:
cv2.imwrite(os.path.join(save_dir, '{:>06d}.png'.format(idx)), img)
ch = cv2.waitKey(25)
if ch == ord('q'):
break
if gif and save_dir is not None:
os.system(
'convert -loop 0 -page +0+0 -delay 25 {0}/*.png {0}/output.gif'.
format(save_dir))
def convert(input_path, output_path, converter, extensions):
"""
Converts DIV2K images using converter preserving the directory structure.
:param input_path: path to DIV2K images
:param output_path: path to DIV2K numpy array to be generated
"""
img_paths = []
for extension in extensions:
img_paths_ext = glob.glob(os.path.join(input_path, '**',
f'*.{extension}'),
recursive=True)
img_paths.extend(img_paths_ext)
for img_path in tqdm(img_paths):
img_dir, img_file = os.path.split(img_path)
img_id, img_ext = os.path.splitext(img_file)
rel_dir = os.path.relpath(img_dir, input_path)
out_dir = os.path.join(output_path, rel_dir)
if not os.path.exists(out_dir):
os.makedirs(out_dir)
img = load_image(img_path)
converter(out_dir, img_id, img)
def depth_inference(dataset='kitti'):
if dataset == 'kitti':
model_input_img_size = (416, 128) # w,h
elif dataset == 'euroc':
model_input_img_size = (384, 256) # w,h
else:
raise Exception('invalid dataset: {}'.format(dataset))
img_in = load_image(FLAGS.input_image_path, resize=model_input_img_size)
inference_model = model.Model(is_training=False,
batch_size=1,
img_height=model_input_img_size[1],
img_width=model_input_img_size[0])
saver = tf.train.Saver()
depth_img = None
with tf.Session() as sess:
checkpoint = tf.train.latest_checkpoint(FLAGS.checkpoint_dir)
saver.restore(sess, checkpoint)
depth_imgs = inference_model.inference_depth([img_in], sess)
depth_img = depth_imgs[0]
print('depth image of dimension: {}\nsample pixel: {}'.format(
depth_img.shape, depth_img[0, 0]))
in_img_name = path.splitext(path.basename(FLAGS.input_image_path))[0]
depth_map_path = '{}/{}_depth.npy'.format(FLAGS.depth_image_dir,
in_img_name)
# cv2.imwrite(depth_image_path, depth_img)
np.save(depth_map_path, depth_img)
logging.info('Depth map written to {}'.format(depth_map_path))
def __init__(self, usealpha):
pygame.sprite.Sprite.__init__(self)
self.image = pygame.Surface((SCREEN_WIDTH, SCREEN_HEIGHT))
self.rect = self.image.get_rect()
if not Water.raster_image:
Water.raster_image = pygame.transform.scale(util.load_image("rasteri"), (SCREEN_WIDTH, SCREEN_HEIGHT))
self.water_levels = []
for i in xrange(self.rect.width):
self.water_levels.append(0.0)
self.t = 0
self.usealpha = usealpha
self.target_amplitude = self.amplitude = SCREEN_HEIGHT / 8.0
self.target_wavelength = self.wavelength = 0.02 * SCREEN_WIDTH / 2.0 / math.pi
self.target_speed = self.speed = 0.06 / math.pi / 2.0 * FPS
self.target_baseheight = self.baseheight = SCREEN_HEIGHT / 24.0 * 8.0
if self.usealpha:
self.image.set_alpha(110)
self.update()
def get_all_predictions(image):
image_features_extract_model = get_architecture(architecture)
attention_plot = np.zeros((max_length, attention_features_shape))
hidden = decoder.reset_state(batch_size=1)
temp_input = tf.expand_dims(load_image(image)[0], 0)
img_tensor_val = image_features_extract_model(temp_input)
img_tensor_val = tf.reshape(
img_tensor_val, (img_tensor_val.shape[0], -1, img_tensor_val.shape[3]))
features = encoder(img_tensor_val)
dec_input = tf.expand_dims([tokenizer.word_index['<start>']], 0)
result = []
for i in range(max_length):
predictions, hidden, attention_weights = decoder(
dec_input, features, hidden)
attention_plot[i] = tf.reshape(attention_weights, (-1, )).numpy()
predicted_id = tf.random.categorical(predictions, 1)[0][0].numpy()
result.append(tokenizer.index_word[predicted_id])
if tokenizer.index_word[predicted_id] == '<end>':
return result, attention_plot
dec_input = tf.expand_dims([predicted_id], 0)
attention_plot = attention_plot[:len(result), :]
return result, attention_plot
def __init__(self, window: Window):
super().__init__(window)
from constants import BUTTON_SIZE
window_size = window.get_size()
window_center = (window_size[0] / 2, window_size[1] / 2)
dpi_factor = window.hidpi_factor
button_size = (BUTTON_SIZE[0] * dpi_factor,
BUTTON_SIZE[1] * dpi_factor)
button_font = Font('sans-serif', 16, dpi_factor)
self.bg_image = util.load_image('assets/background.png')
back_btn = Button(window,
'[ Back ]',
Vector(window_center[0] - button_size[0] / 2,
window_size[1] * 2 / 3),
Vector(*button_size),
Color(0, 102, 255),
Color(255, 255, 255),
Color(0, 80, 230),
Color(255, 255, 255),
font=button_font)
back_btn.set_click_handler(self.back)
self.children.append(back_btn)
def __init__(self, screen, menu, selection=0):
self.screen = screen
if not Menu.sky:
Menu.sky = util.load_image("taivas")
self.water = Water.global_water
self.water_sprite = pygame.sprite.Group()
self.water_sprite.add(self.water)
if not Menu.logo:
Menu.logo = util.load_image("logo")
self.menu = menu
self.selection = selection
self.t = 0
def __load__(self, index):
img_path = self.json_data[index]["image"]
output_img_path = self.json_data[index]["output"]
img = load_image(img_path)
return img, output_img_path
def __init__(self, *args, **kwargs):
''' Not perfect but the bike uses hardcoded constants
Warning! Lots of opaque physics and math
'''
super(Bike, self).__init__(*args, **kwargs)
# Not ideal to use white as the color key
# Not ideal to hardcode the bike image asset
self.original, self.rect = util.load_image('bike.png', (255,255,255))
self.image = self.original
self.speed = 0
self.max_speed = 5
# Is this bike moving?
self.driving = 0
# Each bike has its own target
self.target = Target()
# start at the origin
self.x, self.y = self.rect.centerx, self.rect.centery
self.angle = 0.0
self.dt = 0.0
# Some physics constants. These and the image ought to be parameters
# F_c = mv*v/r --> v_max = sqrt(F_traction/m) * sqrt(r)
self.ft = 5.0
self.mass = 200.0
self.brake = 0.1
self.accel = 0.05
self.draw_cb = []
def __init__(self, screen, menu, selection = 0):
self.screen = screen
if not Menu.sky:
Menu.sky = util.load_image("taivas")
self.water = Water.global_water
self.water_sprite = pygame.sprite.Group()
self.water_sprite.add(self.water)
if not Menu.logo:
Menu.logo = util.load_image("logo")
self.menu = menu
self.selection = selection
self.t = 0
def __init__(self, image_filename, levelmap):
self.levelmap = levelmap
self.__img = util.load_image(image_filename, False, None)
order = range(8)
delay = 4 # each phase of the animation lasts 6 frames
offset = Vector(0,16) # the "position-point" of the hero is on
# his left elbow...
self.size = 16
self.__walk_down = Animation(order)
for down_rect in [ (4+i*24, 0, 16, 31) for i in range(8) ]:
self.__walk_down.add_frame(self.__img, down_rect, delay, offset)
self.__walk_up = Animation(order)
for up_rect in [ (4+i*24, 32, 16, 31) for i in range(8) ]:
self.__walk_up.add_frame(self.__img, up_rect, delay, offset)
self.__walk_left = Animation(order)
for left_rect in [ (4+i*24, 64, 16, 31) for i in range(8) ]:
self.__walk_left.add_frame(self.__img, left_rect, delay, offset)
self.__walk_right = Animation(order)
for right_rect in [ (4+i*24, 96, 16, 31) for i in range(8) ]:
self.__walk_right.add_frame(self.__img, right_rect, delay, offset)
# initial values
self.state = self.DOWN_WALK
# Coordinates are relative to the map - not to the screen!
self.pos = Vector(0,0)
self.speed = 2
def init(self,image_map,tile_x=0,tile_y=0,color_key=None):
"""MapEntity(Surface, tile_x, tile_y, direction)
Surface should be obtained from util.load_image
tile_x & tile_y specify what image map to use if you join
multiple images into one map (Characters, Entities, etc)
legal values are positive integers representing zero based index
direction is what direction the entity should face,
can also be set later with MapEntity.face(direction)
legal values are map.NORTH, map.EAST, map.SOUTH, & map.WEST"""
image = util.load_image(CHARACTERS_DIR, image_map, True, color_key)
Sprite.__init__(self)
self.image_args = (image_map, True, color_key)
self.pos = (0,0)
self.map = None
self.image = image
self.image_base_x = tile_x * 3 * TILE_SIZE
self.image_base_y = tile_y * 4 * TILE_SIZE
self.frame = 0
self.image_tile = Rect( self.image_base_x, self.image_base_y,
TILE_SIZE, TILE_SIZE )
self.rect = Rect(0,0,TILE_SIZE,TILE_SIZE)
self.face(NORTH)
self.next_frame()
self.velocity = (0,0)
self.speed = 4
self.moving = False # For tile based motion
self.always_animate = False
self.animation_count = 1
self.animation_speed = 6
self.entered_tile = False
self.can_trigger_actions = 0
def main():
# TODO: Erase dummy net
net = None
"""
TODO: Comment in
deploy_fpath = 'deploy.prototxt'
model_fpath = 'model.protobinary'
caffe.set_mode_gpu()
net = caffe.Net(deploy_fpath, model_fpath, caffe.TEST)
"""
bpath = '../yandere-crawler/illust/'
code_db = []
# TODO: For train.txt
with open('./test.txt') as f:
for line in f:
preview_fpath, _ = line.rstrip().split(' ')
preview_fpath = bpath + preview_fpath
print preview_fpath
# Make BGR 227x227 image
data = util.load_image(preview_fpath)
# Make code
code = util.make_code(net, data)
code_db.append((code, preview_fpath))
with open('./code_db.pickle', 'wb') as f:
pickle.dump(code_db, f)
def get_colorvariance_features(data_path, pickle_name):
"""
Get Variance of Image Patch
"""
size = len(data_path)
rowPatchCnt = 4
colPatchCnt = 4
var_features = np.zeros((size, colPatchCnt*rowPatchCnt*3))
print var_features.shape
for i in range(size):
if i % 500 == 0: print "{}/{}".format(i, size)
im = util.load_image(data_path[i])
patchH = im.shape[0] / rowPatchCnt
patchW = im.shape[1] / colPatchCnt
im = np.array(im)
#print "***** ", i,"th image, shape : ", im.shape, " *****"
#print "patchW = ", patchW
#print "patchH = ", patchH
#print "{}'s im shape {}".format(i, im.shape)
for w in range(rowPatchCnt):
for h in range(rowPatchCnt):
#print "feature idx : ", 3*(w*rowPatchCnt+h), 3*(w*rowPatchCnt+h+1)
#print "input : ", np.std(im[h*patchH:(h+1)*patchH, w*patchW:(w+1)*patchW].reshape((patchW*patchH, 3)), axis=0)
var_features[i, 3*(w*rowPatchCnt+h):3*(w*rowPatchCnt+h+1)] = np.std(im[h*patchH:(h+1)*patchH, w*patchW:(w+1)*patchW].reshape((patchW*patchH, 3)), axis=0)
pickle.dump(var_features, open(pickle_name, 'wb'), protocol=2)
def __init__(self):
pygame.sprite.Sprite.__init__(self)
self.image = pygame.Surface((SCREEN_WIDTH, SCREEN_HEIGHT))
self.rect = self.image.get_rect()
if not Water.raster_image:
Water.raster_image = util.load_image("rasteri")
self.water_levels = []
for i in xrange(self.rect.width):
self.water_levels.append(0.0)
self.t = 0
self.target_amplitude = self.amplitude = SCREEN_HEIGHT / 8.0
self.target_wavelength = self.wavelength = 0.02 * SCREEN_WIDTH / 2.0 / math.pi
self.target_speed = self.speed = 0.06 / math.pi / 2.0 * FPS
self.target_baseheight = self.baseheight = SCREEN_HEIGHT / 24.0 * 8.0
self.xmul = 2.0 * math.pi / self.wavelength / float(SCREEN_WIDTH)
self.tmul = math.pi * 2.0 / float(FPS) * self.speed
self.image=self.image.convert_alpha()
#~ if Variables.alpha:
#~ self.image.set_alpha(110)
self.update()
def get_HOG_features(data_path, pickle_name):
size = len(data_path)
rowPatchCnt = 4
colPatchCnt = 4
var_features = np.zeros((size, colPatchCnt*rowPatchCnt*3))
print var_features.shape
image = color.rgb2gray(data.astronaut())
#print image
fd, hog_image = hog(image, orientation = 8, pixels_per_cell=(16, 16), cells_per_block = (1,1), visualise=True)
print fd
im = util.load_image(data_path[0])
#print im
#for i in range(size):
#if i % 500 == 0: print "{}/{}".format(i, size)
#im = util.load_image(data_path[i])
#patchH = im.shape[0] / rowPatchCnt
#patchW = im.shape[1] / colPatchCnt
#pass
#im = np.array(im)
pass
def detect_files(self,
base_dir,
names,
centers=None,
dataset=None,
max_batch=64,
is_flip=False):
assert max_batch > 0
if dataset is None:
dataset = self._dataset
batch_imgs = []
batch_centers = []
results = []
for idx, name in enumerate(names):
img = util.load_image(dataset,
os.path.join(base_dir, name),
is_flip=is_flip)
batch_imgs.append(img)
if centers is None:
batch_centers.append(self._center_loader(img))
else:
batch_centers.append(centers[idx, :])
if len(batch_imgs) == max_batch:
for line in self.detect_images(batch_imgs, batch_centers):
results.append(line)
del batch_imgs[:]
del batch_centers[:]
print('{}/{}'.format(idx + 1, len(names)))
if batch_imgs:
for line in self.detect_images(batch_imgs, batch_centers):
results.append(line)
print('done!')
return np.array(results)
def __init__(self):
pygame.sprite.Sprite.__init__(self)
self.image = pygame.Surface((SCREEN_WIDTH, SCREEN_HEIGHT))
self.rect = self.image.get_rect()
if not Water.raster_image:
Water.raster_image = util.load_image("rasteri")
self.water_levels = []
for i in range(self.rect.width):
self.water_levels.append(0.0)
self.t = 0
self.target_amplitude = self.amplitude = SCREEN_HEIGHT / 8.0
self.target_wavelength = self.wavelength = 0.02 * SCREEN_WIDTH / 2.0 / math.pi
self.target_speed = self.speed = 0.06 / math.pi / 2.0 * FPS
self.target_baseheight = self.baseheight = SCREEN_HEIGHT / 24.0 * 8.0
self.xmul = 2.0 * math.pi / self.wavelength / float(SCREEN_WIDTH)
self.tmul = math.pi * 2.0 / float(FPS) * self.speed
self.image = self.image.convert_alpha()
#~ if Variables.alpha:
#~ self.image.set_alpha(110)
self.update()
def __init__(self, world: 'World', level: int, start_pos: Tuple[int, int],
scroll: Vector = Vector(0.05, 0)):
self.level = level
self.start_pos = Vector(
start_pos[0] * BLOCK_SIZE,
(GRID_SIZE[1] - start_pos[1] - 1) * BLOCK_SIZE
)
self.offset = Vector(0, 0)
self.scroll = scroll
self.items: List[LevelItem] = []
self.finished = False
self.counter = 0
self.world = world
self.world.source.last_active_level = self
self.window_size = world.window.get_size()
# Just some initialisation stuff here; less to compute later.
self.background_offset = self.window_size[0] / 2
self.background_image = load_image(LEVEL_BACKGROUND_IMAGE)
self.bg_size = (self.background_image.get_width(), self.background_image.get_height())
self.bg_center = (self.bg_size[0] / 2, self.bg_size[1] / 2)
def __init__(self, group=None):
pygame.sprite.Sprite.__init__(self, group)
self.image = pygame.Surface((769, 50))
self.image.fill(color['background'])
self.text = ''
self.ready = True
self.light = False
self.timer = 0
self.red_light, self.red_pos = \
load_image('red_light.png', -1)
self.green_light, self.green_pos = \
load_image('green_light.png', -1)
self.red_pos.midleft = \
self.image.get_rect().move(10, 0).midleft
self.green_pos.midleft = \
self.image.get_rect().move(10, 0).midleft
def refresh_image(self):
if gv.config['GRAPHICS'] == 'pyglet':
import graphics_pyglet
if self.sprite: self.sprite.delete()
self.sprite = graphics_pyglet.LayeredSprite(name=self.name,batch=util.actor_batch )
self.sprite.add_layer('ActorBase',util.load_image("images/npc_crafty_bot__x1_idle0_png_1354839494_crop.png"))
self.sprite.owner = self
def __init__(self):
self.sprite = util.load_image(Config.path_ballsprite)
self.rect = self.sprite.get_rect()
self.rect.centerx = Config.widthwindow // 2
self.rect.centery = random.randrange(0, Config.heightwindow - self.rect.h)
self.dx = random.choice((1, -1))
self.dy = random.choice((1, -1))
self.speed = 1
def __init__(self, screen):
Menu.__init__(self, screen)
self.x = 180
self.y = 125
self.increment = 40
self.active = True
self.current_option = 0
self.background = load_image("ATOM.png")
self.MenuOptions = ["Go Back"]
def __init__(self, screen):
Menu.__init__(self, screen)
self.x = 180
self.y = 125
self.increment = 40
self.active = True
self.current_option = 0
self.background = load_image("ATOM.png")
self.MenuOptions = ["Begin Adventure", "Load Adventure", "Settings", "Quit"]
