def __init__(self, name, coord, centre=True): # eg ('plus',(30,40))
(x1, y1) = coord
self._instances.append(self)
up = utils.load_image(name + "_up.png", True)
down = utils.load_image(name + "_down.png", True)
w = up.get_width()
h = up.get_height()
x = x1
y = y1
if centre:
self.cx = x
self.cy = y
x = x - w / 2
y = y - h / 2
else:
self.cx = x + w / 2
self.cy = y + h / 2
self.rect = pygame.Rect(x, y, w, h)
self.name = name
self.x = x
self.y = y
self.active = True
self.up = up
self.down = down
self.stay_down = False
def main():
#Initialize
pygame.init()
screen = pygame.display.set_mode((width, height))
pygame.display.set_caption(WINDOW_TITLE)
screen.fill(bg_color)
clock = pygame.time.Clock()
font = pygame.font.Font(font_path, fonth)
img_reglas = load_image(reglas_path)
img_creditos = load_image(creditos_path)
pygame.mixer.music.load(menu_music)
pygame.mixer.music.play()
while True:
menu = Menu(screen, font, ['Jugar', 'Reglas', 'Creditos', 'Salir'])
op = menu.main_loop()
if op == 0:
game = SC(screen, clock)
game.main_loop()
elif op == 1:
SimpleScreen(screen, img_reglas).main_loop()
elif op == 2:
SimpleScreen(screen, img_creditos).main_loop()
elif op == 3:
sys.exit(0)
def start(self):
"""Mandatory method."""
self.GoodSound=utils.load_sound(os.path.join(self.CPdatadir, 'good.ogg'))
self.WrongSound=utils.load_sound(os.path.join(self.CPdatadir, 'wrong.ogg'))
p = os.path.join(self.CPdatadir,'good_%s.png' % self.lang)
if not os.path.exists(p):
p = os.path.join(self.CPdatadir,'thumbs.png')
self.ThumbsUp = SPSpriteUtils.MySprite(utils.load_image(p))
i = utils.load_image(os.path.join(self.my_datadir, 'hint.png'))
i_ro = utils.load_image(os.path.join(self.my_datadir, 'hint_ro.png'))
self.HintBut = SimpleTransImgButton(i,i_ro, (370, 200))
if int(self.rchash[self.theme]['show_errors']):
self.wrongImg = SPSpriteUtils.MySprite(utils.load_image(os.path.join(self.my_datadir, 'incorrect.png')))
else:
self.wrongImg = None
prev = os.path.join(self.my_datadir, 'findit_prev.png')
prev_ro = os.path.join(self.my_datadir, 'findit_prev_ro.png')
next = os.path.join(self.my_datadir, 'findit_next.png')
next_ro = os.path.join(self.my_datadir, 'findit_next_ro.png')
self.prevnextBut = TransPrevNextButton((370, 460), \
self._cbf_prevnext_button, \
prev, prev_ro, next, next_ro)
self.imgdir = os.path.join(self.my_datadir, 'images', self.theme)
if not os.path.exists(self.imgdir):
self.imgdir = os.path.join(self.my_datadir, 'images','default')
self.score = 0
self.AreWeDT = False
# get language code
loclang = utils.get_locale_local()[0]
def start_exercise(self):
if self.blit_pos[1] == 0:
y = 10
else:
y = 110
k = random.choice(self.ImgDiffHash.keys())
v = self.ImgDiffHash[k]
del self.ImgDiffHash[k]
ImgA = Img_Display(utils.load_image(k+'A.jpg'), v,\
(self.GoodSound, self.WrongSound), self.wrongImg, self.rchash)
ImgA.set_position(15, y)
ImgA.name = 'ImgA'# needed for debugging only
ImgB = Img_Display(utils.load_image(k+'B.jpg'), v,\
(self.GoodSound, self.WrongSound), self.wrongImg, self.rchash)
ImgB.set_position(435, y)
ImgB.name = 'ImgB'
ImgA.register_observer(ImgB.observer)
ImgB.register_observer(ImgA.observer)
self.currentlist = [ImgA, ImgB]
self.HintBut.connect_callback(ImgA.show_hint, MOUSEBUTTONUP, self)
self.HintBut.display_sprite()
#self.prevnextBut.enable(False)
self.actives.add(self.HintBut)
self.actives.add([ImgA, ImgB])
if self.previous_screen and not self.AreWeDT:
self.actives.add(self.prevnextBut.get_actives())
self.prevnextBut.enable(True)
self.actives.redraw()
self.ImgA, self.ImgB = ImgA, ImgB
self.done += 1
def __init__(self):
# Setup GUI
self.playerselection = 0
defaultStyle.init(gui)
self.desktop = gui.Desktop()
self.win = gui.Window(position = (800,0), size = (200,600), parent = self.desktop, text = 'Statistics and Help')
self.lbl = gui.Label(position = (2, 30), text = '---- Mini-map Key ----', parent = self.win)
self.movbtn = gui.OnImageButton(utils.load_image('movebx.png'), position = (15, 50), parent = self.win)
self.mvlbl = gui.Label(position = (25, 45), text = 'Moving / Living Player', parent = self.win)
self.atkbtn = gui.OnImageButton(utils.load_image('atkbx.png'), position = (15, 70), parent = self.win)
self.atklbl = gui.Label(position = (25, 65), text = 'Attacking Player', parent = self.win)
self.deadbtn = gui.OnImageButton(utils.load_image('deadbx.png'), position = (15, 90), parent = self.win)
self.deadlbl = gui.Label(position = (25, 85), text = 'Slain Player', parent = self.win)
self.ovbtn = gui.OnImageButton(utils.load_image('ovbx.png'), position = (15, 110), parent = self.win)
self.ovlbl = gui.Label(position = (25, 105), text = 'Overlord Player', parent = self.win)
self.statslbl = gui.Label(position = (2, 130), text = '---- Player List ----', parent = self.win)
self.playerstats = gui.ListBox(position = (2, 150), size = (196, 200), parent = self.win)
self.playerstats.onItemSelected = self.itemSelected
self.lbl_title_pos = gui.Label(position = (5, 350), text='Player (id:#): Status - ', parent = self.win)
self.lbl_pos = gui.Label(position = (5, 365), text='Location: ( #, # )', parent = self.win)
self.lbl_health = gui.Label(position = (5, 380), text='Health: # / 25', parent = self.win)
self.lbl_ai_courage = gui.Label(position = (5, 395), text='AI Courage: #', parent = self.win)
self.lbl_ai_camper = gui.Label(position = (5, 410), text='AI Camper: #', parent = self.win)
self.lbl_ai_clingy = gui.Label(position = (5, 425), text='AI Clingy: #', parent = self.win)
self.lbl_ai_stack = gui.Label(position = (5, 440), text='AI Stack: #', parent = self.win)
self.player_img_alive = gui.OnImageButton(utils.load_sliced_sprites(32, 32, 'characters/zelda_atk.png')[0], position = (100,420), parent = self.win, enabled = False)
self.player_img_dead = gui.OnImageButton(utils.load_sliced_sprites(32, 32, 'characters/zelda_dead.png')[0], position = (100,420), parent = self.win, enabled = False)
def main():
pygame.init()
screen = pygame.display.set_mode(WINDOW)
pygame.display.set_caption(WINDOW_TITLE)
intro = load_image(INTRO)
final = load_image(INTRO)
while True:
Play(screen, intro).play()
level1 = load_image(NEXT0)
screen.blit(level1, (0,0))
pygame.display.flip()
pygame.time.delay(2000)
cancionwav = None
for level in LEVELS:
bg = load_image(level['bg'])
cuerdas = [int(x) for x in level['cuerdas']]
cancion = [int(x) for x in level['cancion']]
if cancionwav:
cancionwav.stop()
cancionwav = load_sound(level['wav'])
next = load_image(level['next'])
Play(screen, bg, cancionwav, cuerdas).play()
lev = Level(screen, cuerdas, cancion, cancionwav, next)
lev.loop()
Play(screen, final).play()
def __init__(self, names):
super(TextureGroupIndividual, self).__init__()
atlas = TextureAtlas(64*len(names), 64)
self.texture = atlas.texture
self.texture_data = []
i=0
for name in names:
if not name in BLOCK_TEXTURE_DIR:
if G.TEXTURE_PACK != 'default':
BLOCK_TEXTURE_DIR[name] = load_image('resources', 'texturepacks', G.TEXTURE_PACK, 'textures', 'blocks', name + '.png')
else:
BLOCK_TEXTURE_DIR[name] = load_image('resources', 'texturepacks', 'textures', 'blocks', name + '.png')
if not BLOCK_TEXTURE_DIR[name]:
return None
subtex = atlas.add(BLOCK_TEXTURE_DIR[name].get_region(0,0,64,64))
for val in subtex.tex_coords:
i += 1
if i % 3 != 0: self.texture_data.append(val) #tex_coords has a z component we don't utilize
#Repeat the last texture for the remaining sides
# (top, bottom, side, side, side, side)
# ie: ("dirt",) ("grass_top","dirt","grass_side")
# Becomes ("dirt","dirt","dirt","dirt","dirt","dirt") ("grass_top","dirt","grass_side","grass_side","grass_side","grass_side")
self.texture_data += self.texture_data[-8:]*(6-len(names))
def _splash_controls(self):
Img.screen.fill((0,0,0))
txt = _("Use these keys on your keyboard to control the bat.")
txtlist = utils.txtfmt([txt],36)
s1,spam = utils.text2surf(txtlist[0],18,GREEN, bold=True)
s2,spam = utils.text2surf(txtlist[1],18,GREEN, bold=True)
Img.screen.blit(s1,(100,200))
Img.screen.blit(s2,(100,240))
pygame.display.update()
rects = []
fsize = 24
surf = pygame.Surface((60,300))
surf.blit(utils.load_image(os.path.join(self.my_datadir,'arrow_up.png')),(4,0))
#surf.blit(utils.load_image(os.path.join(self.my_datadir,'bat.png')),(26,120))
surf.blit(utils.load_image(os.path.join(self.my_datadir,'arrow_down.png')),(4,240))
surf_r = surf.convert()# copy for the right side
if ONEPLAYER == 0 and PCPLAYER == 0:
surf.blit(utils.char2surf(self.rc_dic['left_keyup'].upper(),fsize,GREEN, bold=True),(16,70))
surf.blit(utils.char2surf(self.rc_dic['left_keydown'].upper(),fsize,GREEN, bold=True),(16,190))
surf_r.blit(utils.char2surf(self.rc_dic['right_keyup'].upper(),fsize,GREEN, bold=True),(16,70))
surf_r.blit(utils.char2surf(self.rc_dic['right_keydown'].upper(),fsize,GREEN, bold=True),(16,190))
rects.append(Img.screen.blit(surf,(40,100)))
rects.append(Img.screen.blit(surf_r,(700,100)))
pygame.display.update(rects)
pygame.time.wait(4000)
self.skipssplash = 1
def pre_level(self,level):
"""Mandatory method.
Return True to call the eventloop after this method is called."""
self.logger.debug("pre_level called with: %s" % level)
if not self.runme:
return
self.SPG.tellcore_disable_level_indicator()
self.SPG.tellcore_disable_score_button()
self.screen.blit(self.backsquare, (50, 110))
txt = [_("If you ready to start the next activity, hit the 'start' button.")]
txt = utils.txtfmt(txt, 40)
y = 200
for t in txt:
surf = utils.char2surf(t,28,WHITE)
r = self.screen.blit(surf, (80, y))
pygame.display.update(r)
y += 50
startbutpath = utils.load_image(os.path.join(self.my_datadir, 'start.png'))
startbutpath_ro = utils.load_image(os.path.join(self.my_datadir, 'start_ro.png'))
self.startbutton = SPWidgets.TransImgButton(startbutpath, startbutpath_ro, \
(300, 350), fsize=32, text= _("Start"), fcol=WHITE)
self.startbutton.connect_callback(self._cbf, MOUSEBUTTONDOWN, 'start')
self.startbutton.set_use_current_background(True)
self.startbutton.display_sprite()
self.actives.add(self.startbutton)
self.start_loop_flag = True
self.PB.update()
return True
def start(self):
"""Mandatory method."""
self.SPG.tellcore_set_dice_minimal_level(6)
fs = 36
self.scoreboard = ScoreBoard(self.rc_dic, size=fs)
Img.winner = utils.load_image(os.path.join(self.my_datadir,'winner.jpg'),1)
Img.loser = utils.load_image(os.path.join(self.my_datadir,'loser.jpg'),1)
self.skipstart = None# used when the user sets a predefined game play in the config file
self.skipsplash = None
if self.rc_dic['sound'].lower() == 'no':
Snd.pong = utils.load_sound(os.path.join(self.my_datadir,''))
Snd.winner = utils.load_sound(os.path.join(self.my_datadir,''))
Snd.goal = utils.load_sound(os.path.join(self.my_datadir,''))
Snd.bump = utils.load_sound(os.path.join(self.my_datadir,''))
else:
Snd.pong = utils.load_sound(os.path.join(self.my_datadir,'pick.wav'))
Snd.winner = utils.load_music(os.path.join(self.my_datadir,'winner.ogg'))
Snd.goal = utils.load_sound(os.path.join(self.my_datadir,'goal.wav'))
Snd.bump = utils.load_sound(os.path.join(self.my_datadir,'bump.wav'))
#set kind of game play
# we only check for multi and multipc, anything else is considerd single play
# which is the default
if self.rc_dic['gameplay'] == 'multi':
self.restart([[None,'2']])
self.skipstart = 1
elif self.rc_dic['gameplay'] == 'multipc':
self.restart([[None,'3']])
self.skipstart = 1
def __init__(self, stage_file="level_1"):
self.level_data, self.rect = utils.load_image("{0}.gif".format(stage_file))
self.ratio = 16 # ratio of pixel in stage file / pixel in game
pygame.Surface.__init__(self, (self.rect.width * self.ratio, self.rect.height * self.ratio))
self.counter = 0
self.scrolled = 0
self.fill((0, 0, 0))
self.set_colorkey((0, 0, 0))
self.limits = []
self.colors = {
"grass": (0, 0, 0, 255),
"enemies": (255, 0, 0, 255),
"miniboss": (0, 0, 255, 255),
"boss": (0, 255, 0, 255),
"bg": (229, 229, 229, 255),
}
cached_image = False
# Using the previously generated image for the stage
# TODO, create hash of the source image for the level, to detect changes in it
self.rect = self.rect.move((1, 0))
try:
# Load the cached image
cached_image, temp_rect = utils.load_image("{0}_processed.png".format(stage_file))
self.blit(cached_image, (0, 0))
# Detect limits
self.calculate_limits()
except pygame.error, message:
print message
def __init__(self, screen_dims):
Dude.__init__(self, screen_dims)
self.default_image, self.rect = load_image("res/player_base.png", -1)
self.left_shoot_image, _ = load_image("res/player_shoot_left.png", -1)
self.right_shoot_image, _ = load_image("res/player_shoot_right.png", -1)
self.image = self.default_image
self.jump_power = -10
def __init__(self, path, hpath, pos=(0, 0), padding=4,text='',fsize=24, fcol=BLACK, name='', **kwargs):
"""Button which shows an image but has a fully transparent background.
When a hover event occurs the image is changed.
path - must be the path to the image file or a pygame surface
hpath - must be the path to the image file or a pygame surface that will
be shown when a hover event occurs.
pos - position to display the box
rect - Rect indicating the size of the box
padding - space in pixels around the text
name - string to indicate this object
text - when a sting is given it will be blitted over the image.
fsize - fontsize.
"""
self.text = text
self.fsize = fsize
if type(path) in types.StringTypes:
image = utils.load_image(path)
else:
image = path
if hpath:
if type(hpath) in types.StringTypes:
self.hs = utils.load_image(hpath)
else:
self.hs = hpath
else:
self.hs = utils.grayscale_image(image.convert_alpha())
if self.text:
s = utils.char2surf(text, fsize, fcol)
r = image.get_rect()
sr = s.get_rect()
sr.center = r.center
image.blit(s, sr)
self.hs.blit(s, sr)
ImgButton.__init__(self, image, pos, padding=padding, name=name)
def __init__(self, screen):
self.screen = screen
self.allsprites = pygame.sprite.LayeredDirty()
self.background = pygame.Surface(self.screen.get_size())
self.background, self.rect = utils.load_image('nasa_flame.jpg', -1)
self.player_ship = ship.ObjShip()
button_image, button_rect = utils.load_image('buttons_red.png', -1)
button_frames = [ (0,0,116,31), (116,0,116,31), (233,0,116,31) ]
self.button = simple_button.BtnSimple(button_image, button_rect, button_frames)
self.button.rect.topleft = 270, 240
pygame.font.init()
self.default_font = pygame.font.SysFont("Arial", 48)
self.screen.blit(self.background, (0,0))
self.button_label = dirtytext.DirtyText ("Play Again", "None", 286, 245, 24, (255, 255, 255))
self.message_victory = dirtytext.DirtyText( "You Won!", "None", 275, 200, 32, (255, 255, 0))
self.allsprites.add(self.message_victory)
self.allsprites.add(self.button)
self.allsprites.add(self.button_label)
self.allsprites.add(self.player_ship)
self.allsprites.clear(self.screen, self.background)
pygame.display.flip()
self.running = True
self.alive = True
def setImages(self, rightAndLeftImages=['snail1Right.png', 'snail1Left.png']):
"""
Load the different images so we can use them later when moving
"""
self.rightAndLeftImages = rightAndLeftImages
# Load every snail sprite
self.image = load_image(rightAndLeftImages[0])
self.image_down_right = load_image(rightAndLeftImages[0])
self.image_down_left = load_image(rightAndLeftImages[1])
self.image_up_left = pygame.transform.rotate(self.image_down_right, 180)
self.image_up_right = pygame.transform.rotate(self.image_down_left, 180)
self.image_left_up = pygame.transform.rotate(self.image_down_left, 270)
self.image_left_down = pygame.transform.rotate(self.image_down_right, 270)
self.image_right_up = pygame.transform.rotate(self.image_down_right, 90)
self.image_right_down = pygame.transform.rotate(self.image_down_left, 90)
if self.gravity_direction == Direction.DOWN:
# Use the correct sprite
self.image = self.image_down_right
if self.gravity_direction == Direction.UP:
# Use the correct sprite
self.image = self.image_up_right
if self.gravity_direction == Direction.LEFT:
# Use the correct sprite
self.image = self.image_left_up
if self.gravity_direction == Direction.RIGHT:
# Use the correct sprite
self.image = self.image_right_up
def load_bg(self):
fondo = load_image(FONDO)
porta = load_image(PORTA)
playbg = load_image(PLAYBG)
self.bg = pygame.Surface(WINDOW)
self.bg.blit(fondo, (0,0))
self.bg.blit(porta, (0,340))
self.bg.blit(playbg, (500,340))
def start(self):
"""Mandatory method."""
Hole.img = utils.load_image(os.path.join(self.my_datadir,'hole.png'))
Hole.size = (Hole.img.get_width(), Hole.img.get_height())
self.backgr_wohole = utils.load_image(os.path.join(self.my_datadir,'backgr.png'))
Snd.throw = os.path.join(self.my_datadir,'sndt.wav')
Snd.hurra = os.path.join(self.my_datadir,'sndh.wav')
Snd.great = os.path.join(self.my_datadir,'sndh.wav')
def next_level(self,level,dbmapper):
"""Mandatory method.
Return True if there levels left.
False when no more levels left."""
self.Sound.dealcard1.play()
self.logger.debug("next_level called with %s" % level)
if level > 6: return False # We only have 6 levels
if level == self.level:
self.levelrestartcounter += 1
self.level = level
# used to record how many times the same card is shown.
# we store it into a class namespace to make it globally available.
Global.selected_cards = {}
Card.Selected = None
# db_mapper is a Python class object that provides easy access to the
# dbase.
self.db_mapper = dbmapper
# make sure we don't have any sprites left in our group
self.actives.empty()
# reset the screen to clear any crap from former levels
self.clear_screen()
# here we setup the card layout for each level (6 levels), list[0] is level 1 ect
# (4,2) means 4 collomns of 2 rows
level_layout = [(3,2),(4,2),(4,3),(4,4),(5,4),(6,4)]
# store number of cards into the db table 'cards' col
a,b = level_layout[level-1]
self.db_mapper.insert('cards',a*b)
self.num_of_cards = a*b//2# how many cards do we need in total?
self.levelupcount = 1
# we don't keep references to them as we query the sprites themself.
imagelist = []
# load all the images we need
try:
imgdir = os.path.join(self.my_datadir, self.tile, self.theme)
if self.rchash.has_key(self.theme):
cardfront = self.rchash[self.theme]['cardfront']
else:
cardfront = self.rchash['childsplay']['cardfront']
emptycard = utils.load_image(os.path.join(imgdir,cardfront))
images = glob.glob(os.path.join(imgdir,'*A.*'))
images = random.sample(images, self.num_of_cards)
#self.logger.debug("Contents of my_images %s" % myimages)
for imgfile in images:
# load and put the images in a list together with their file name - A | B
# which we use as a id for the sprite later on
file = os.path.basename(imgfile)
# The A file
img = utils.load_image(imgfile)
imagelist.append((img,file[:-5]))
# The B file
img = utils.load_image(imgfile.replace('A','B', 1))
imagelist.append((img,file[:-5]))
except (StandardError,utils.MyError),info:
self.logger.exception("Can't load images for sprites: %s" % info)
raise utils.MyError(str(info))# MyError will make the core end this game
def _setup(self, THEME, pos, actives, cbf, usebutton=True):
self.imgstar0 = utils.load_image(os.path.join(THEMESPATH, self.theme,'star0.png'))
self.imgstar1 = utils.load_image(os.path.join(THEMESPATH, self.theme,'star1.png'))
self.rectstar = self.imgstar0.get_rect()
#self.image = pygame.Surface((self.rectstar.w * self.maxlevels, self.rectstar.h))
#self.image.fill(self.THEME['starbutton_bg_color'])
self.image = pygame.Surface((self.rectstar.w * self.maxlevels, self.rectstar.h), SRCALPHA)
self.image.fill((0, 0, 0, 0))
self.pos = pos
self._set_level(1)
def init(self, numbers, positions):
self.totalblocks += len(numbers)
self.blocklist = []
for i in numbers:
wimg = utils.load_image(os.path.join(self.datadir, 'w%s.png' % i))
gimg = utils.load_image(os.path.join(self.datadir, 'g%s.png' % i))
b = Block(i, positions[i-1], wimg, self.white, gimg, self.red)
self.blocklist.append(b)
b.connect_callback(self._cbf_block, MOUSEBUTTONDOWN, i)
self.currentID = 1
def __init__(self, datadir, actives, goodsnd, wrongsnd, observer):
self.actives = actives
self.datadir = datadir
self.good = goodsnd
self.wrong = wrongsnd
self.observer = observer
self.red = utils.load_image(os.path.join(datadir, 'r.png'))
self.white = utils.load_image(os.path.join(datadir, 'w.png'))
self.errors = 0
self.totalblocks = 0
def __init__(self):
pygame.sprite.Sprite.__init__(self)
self.image_still, self.rect = utils.load_image('tender.png')
self.image_moving, foo = utils.load_image('tender_moving.png')
self.image = self.image_moving
self.cur_lane = 0
self.num_lanes = 4
self.state = Bartender.STILL
#When the player goes left and right, the bartender goes "inside the bar"
self.inside_bar = 0
def change_image(self):
if self.mode == 0:
image = load_image('resources', 'textures', 'inventory.png')
elif self.mode == 1:
image = load_image('resources', 'textures', 'inventory_when_crafting_table.png')
elif self.mode == 2:
image = load_image('resources', 'textures', 'inventory_when_furnace.png')
self.frame = image_sprite(image, self.batch, 0)
self.frame.x = (self.parent.window.width - self.frame.width) / 2
self.frame.y = self.icon_size / 2 - 4
def _init(M):
M.button_image, M.button_highlighted, M.button_disabled = init_button_image()
M.background_image = load_image('resources', 'textures', 'main_menu_background.png')
M.backdrop_images = []
M.rnd_backdrops = ('main_menu_background.png', 'main_menu_background_2.png', 'main_menu_background_3.png',
'main_menu_background_4.png', 'main_menu_background_5.png', 'main_menu_background_6.png')
for backdrop in M.rnd_backdrops:
M.backdrop_images.append(load_image('resources', 'textures', backdrop))
M.backdrop = random.choice(M.backdrop_images)
def __init__(self, screen):
self.font = utils.load_font('chitown.ttf', 24)
self.background, foo = utils.load_image('background.png')
self.logo, foo = utils.load_image('logo.png')
self.screen = screen
self.chosen_option = 0
self.age = 0
self.selected_option = -1
self.events = [] #So the subclasses can inspect input events
self.finished = False
self.line_height = 60
self.left_margin = 152
def __init__(self, path, hpath, text, pos=(0, 0), textpos=2, padding=4, fsize=24,\
fgcol=BLACK, name='', **kwargs):
"""Button which shows an image and text.
path - must be the path to the image file.
hpath - 'rollover' image path.
pos - position to display the box
rect - Rect indicating the size of the box
padding - space in pixels around the text
name - string to indicate this object
text - text to display. String will be split on \n.
textpos - position of the text, 1 means left from the image, 2 means right from the image
"""
image = utils.load_image(path)
imageh = utils.load_image(hpath)
surflist = []
surfhlist = []
for line in text.split('\n'):
if line == '':
line = ' '
surflist.append(utils.char2surf(line, fcol=fgcol, fsize=fsize, ttf=TTF))
surfhlist.append(utils.char2surf(line, fcol=GREY, fsize=fsize, ttf=TTF))
w = max([s.get_width() for s in surflist])
h = surflist[0].get_height()
totalh = h * len(surflist)
textsurf = pygame.Surface((w, totalh), SRCALPHA)
y = 0
for s in surflist:
textsurf.blit(s, (0, y))
y += h
textsurf_h = pygame.Surface((w, totalh), SRCALPHA)
y = 0
for s in surfhlist:
textsurf_h.blit(s, (0, y))
y += h
w = image.get_width() + w + padding * 2
h = max(image.get_height(), totalh)
surf = pygame.Surface((w, h), SRCALPHA)
hsurf = surf.copy()
image_y = (surf.get_height() - image.get_height()) / 2
text_y = (surf.get_height() - textsurf.get_height()) / 2
if textpos == 1:
surf.blit(textsurf, (0, text_y))
surf.blit(image, (textsurf.get_width() + padding, image_y))
hsurf.blit(textsurf_h, (0, text_y))
hsurf.blit(imageh, (textsurf_h.get_width() + padding, image_y))
else:
surf.blit(image, (0, image_y))
surf.blit(textsurf, (image.get_width() + padding, text_y))
hsurf.blit(imageh, (0, image_y))
hsurf.blit(textsurf_h, (imageh.get_width() + padding, text_y))
TransImgButton.__init__(self, surf, hsurf, pos=pos, padding=padding, \
fsize=fsize, fcol=fgcol, name=name)
def __init__(self, screen):
pygame.Surface.__init__(self, screen) #call Sprite intializer
self.convert()
self.screen = screen
self.fill((250, 250, 250))
self.back_image, self.back_rect = utils.load_image('background.jpg');
self.warning_image, self.warning_rect = utils.load_image('warning.png');
self.back_rect_init = self.back_rect.copy()
self.status = Background.IDLE
#counter to switch warning on and off
self.status_count = 0
self.status_count_max = 50
self.counter = 0
def get_func_exprs():
"""
Prompt for a list of functions the user wants to see graphed.
As mentioned previously, anything entered remains for the duration
of the program, so you can graph something, change the settings, and
return to find your functions still there.
"""
def change_colors(item):
# index new color
item_index = button_entries.index(item)
COL_POS_LIST[item_index] += 1
# reset index if gone too far
if COL_POS_LIST[item_index] >= len(COLOR_LIST):
COL_POS_LIST[item_index] = 0
# create new Button image
col = item.image.copy()
col.fill(COLOR_LIST[COL_POS_LIST[item_index]])
# update Button
item.set_new_image(col)
item.color = COLOR_LIST[COL_POS_LIST[item_index]]
box = gui.Container()
box.add(
gui.Button(10, 10, utils.load_image("cube.bmp", True), "Back"))
box.add(
gui.Button(constants.SCR_WIDTH - 70, 10,
utils.load_image("cube.bmp", False), "Graph!"))
box.add(text_entries)
box.add(button_entries)
while True:
if pygame.event.peek(QUIT):
utils.quit()
box.update(*pygame.event.get())
for item in box:
if isinstance(item, gui.Button) and item.clicked:
item.clicked = False
if item.text == "Back":
return
elif item.text == "":
change_colors(item)
elif item.text == "Graph!":
exprs = [(x.expr_text, y.color) for x, y in zip(text_entries, button_entries) if x.expr_text]
draw_graph(exprs)
blit_background()
box.draw(SCREEN)
pygame.display.update()
def __init__ (self,
width=IMAGE_SIZE,
height=IMAGE_SIZE,
frame_color=None,
prepare_btn_cb=prepare_btn,
method=RESIZE_CUT,
image_dir=None,
parent=None):
gtk.Table.__init__(self, 2,5,False)
self._parent = parent
self._signals = []
self.width = width
self.height = height
self.image = gtk.Image()
self.method = method
#self.set_myownpath(MYOWNPIC_FOLDER)
img_box = BorderFrame(border_color=frame_color)
img_box.add(self.image)
img_box.set_border_width(5)
self._signals.append((img_box, img_box.connect('button_press_event', self.emit_image_pressed)))
self.attach(img_box, 0,5,0,1,0,0)
self.attach(gtk.Label(), 0,1,1,2)
self.bl = gtk.Button()
il = gtk.Image()
il.set_from_pixbuf(load_image(os.path.join(iconpath, 'arrow_left.png')))
self.bl.set_image(il)
self.bl.connect('clicked', self.previous)
self.attach(prepare_btn_cb(self.bl), 1,2,1,2,0,0)
cteb = gtk.EventBox()
self.cat_thumb = gtk.Image()
self.cat_thumb.set_size_request(THUMB_SIZE, THUMB_SIZE)
cteb.add(self.cat_thumb)
self._signals.append((cteb, cteb.connect('button_press_event', self.emit_cat_pressed)))
self.attach(cteb, 2,3,1,2,0,0,xpadding=10)
self.br = gtk.Button()
ir = gtk.Image()
ir.set_from_pixbuf(load_image(os.path.join(iconpath,'arrow_right.png')))
self.br.set_image(ir)
self.br.connect('clicked', self.next)
self.attach(prepare_btn_cb(self.br), 3,4,1,2,0,0)
self.attach(gtk.Label(),4,5,1,2)
self.filename = None
self.show_all()
self.image.set_size_request(width, height)
if image_dir is None:
image_dir = os.path.join(mmmpath, "mmm_images")
self.set_image_dir(image_dir)
def init(): # called by run()
random.seed()
global redraw
global screen, w, h, font1, font2, clock
global factor, offset, imgf, message, version_display
global pos, pointer
redraw = True
version_display = False
screen = pygame.display.get_surface()
pygame.display.set_caption(app)
screen.fill((70, 0, 70))
pygame.display.flip()
w, h = screen.get_size()
if float(w) / float(h) > 1.5: # widescreen
offset = (w - 4 * h / 3) / 2 # we assume 4:3 - centre on widescreen
else:
h = int(0.75 * w) # allow for toolbar - works to 4:3
offset = 0
factor = float(h) / 24 # measurement scaling factor (32x24 = design units)
imgf = float(h) / 900 # image scaling factor - images built for 1200x900
clock = pygame.time.Clock()
if pygame.font:
t = int(80 * imgf)
font1 = pygame.font.Font(None, t)
t = int(96 * imgf)
font2 = pygame.font.Font(None, t)
message = ""
pos = pygame.mouse.get_pos()
pointer = utils.load_image("pointer.png", True)
pygame.mouse.set_visible(False)
# this activity only
global score, best, state, ms, message_cxy, bgd, score_cxy, best_cxy
global help_img, help_on, help_cxy
score = 0
best = 0
state = 1
# 1 displaying given
# 2 accepting input
# 3 right
# 4 wrong
ms = pygame.time.get_ticks()
message_cxy = None # set in let.py
bgd = utils.load_image("bgd.png", False)
cy = sy(19)
score_cxy = (sx(16), cy)
best_cxy = (sx(26), cy)
help_img = utils.load_image("help.png", False)
help_cxy = (sx(16), sy(10))
help_on = False
# -*- coding:utf-8 -*-
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
import vgg16
import utils
from Nclasses import labels
# 待识别图片的路径
img_path = raw_input('Input the path and image name:')
# 对待识别图片进行预处理
img_ready = utils.load_image(img_path)
# 打印img_ready的维度
# print("img_ready shape", tf.Session().run(tf.shape(img_ready)))
# 理论上输出 [1 224 224 3]
# 打印柱状图
fig = plt.figure(u"Top-5 预测结果")
with tf.Session() as sess:
# 给输入的特征图片占位
images = tf.placeholder(tf.float32, [1, 224, 224, 3])
# 实例化 vgg
vgg = vgg16.Vgg16()
# 运行前向神经网络结构，复现神经网络结构
vgg.forward(images)
# 将待识别图像作为输入喂入计算 softmax的节点vgg.prob
# 网络的输出probability就是通过vgg16网络的前向传播过程
# 预测出的一千个分类的概率分布
probability = sess.run(vgg.prob, feed_dict={images: img_ready})
# 把probability列表中概率最高的五个所对应的probabilty列表的
def gameplay(self):
gamespeed = 4
startMenu = False
gameOver = False
gameQuit = False
playerDino = Dino(self.screen,44,47)
new_ground = Ground(self.screen,-1*gamespeed)
scb = Scoreboard(self.screen)
highsc = Scoreboard(self.screen,ct.width*0.78)
counter = 0
cacti = pg.sprite.Group()
pteras = pg.sprite.Group()
clouds = pg.sprite.Group()
last_obstacle = pg.sprite.Group()
Cactus.containers = cacti
Ptera.containers = pteras
Cloud.containers = clouds
retbutton_image,retbutton_rect = ut.load_image('replay_button.png',35,31,-1)
gameover_image,gameover_rect = ut.load_image('game_over.png',190,11,-1)
temp_images,temp_rect = ut.load_sprite_sheet('numbers.png',12,1,11,int(11*6/5),-1)
HI_image = pg.Surface((22,int(11*6/5)))
HI_rect = HI_image.get_rect()
HI_image.fill(ct.background_col)
HI_image.blit(temp_images[10],temp_rect)
temp_rect.left += temp_rect.width
HI_image.blit(temp_images[11],temp_rect)
HI_rect.top = ct.height*0.1
HI_rect.left = ct.width*0.73
while not gameQuit:
while startMenu:
pass
while not gameOver:
if pg.display.get_surface() == None:
print("Couldn't load display surface")
gameQuit = True
gameOver = True
else:
##########
frame = self.cam.get_frame()
frame = cv2.resize(frame,self.im_shape)
frame = np.reshape(frame,(1,self.im_shape[0],self.im_shape[1],3))
out = self.model.predict(frame)
CLS = {0:'Center',1:'Top',2:'Bottom'}
print(CLS[int(out[0])],)
if True:
for event in pg.event.get():
if event.type==pg.QUIT:
gameQuit = True
gameOver = True
if out[0]==1:
if playerDino.rect.bottom == int(0.98*ct.height):
playerDino.isJumping = True
if pg.mixer.get_init() != None:
self.jump_sound.play()
playerDino.movement[1] = -1*playerDino.jumpSpeed
elif out[0]==0:
playerDino.isDucking = False
elif out[0]==2:
if not (playerDino.isJumping and playerDino.isDead):
playerDino.isDucking = True
if False:
for event in pg.event.get():
if event.type == pg.QUIT:
gameQuit = True
gameOver = True
if event.type == pg.KEYDOWN:
if event.key == pg.K_SPACE:
if playerDino.rect.bottom == int(0.98*ct.height):
playerDino.isJumping = True
if pg.mixer.get_init() != None:
self.jump_sound.play()
playerDino.movement[1] = -1*playerDino.jumpSpeed
if event.key == pg.K_DOWN:
if not (playerDino.isJumping and playerDino.isDead):
playerDino.isDucking = True
if event.type == pg.KEYUP:
if event.key == pg.K_DOWN:
playerDino.isDucking = False
##########
for c in cacti:
c.movement[0] = -1*gamespeed
if pg.sprite.collide_mask(playerDino,c):
playerDino.isDead = True
if pg.mixer.get_init() != None:
self.die_sound.play()
for p in pteras:
p.movement[0] = -1*gamespeed
if pg.sprite.collide_mask(playerDino,p):
playerDino.isDead = True
if pg.mixer.get_init() != None:
self.die_sound.play()
if len(cacti) < 2:
if len(cacti) == 0:
last_obstacle.empty()
last_obstacle.add(Cactus(self.screen,gamespeed,40,40))
else:
for l in last_obstacle:
if l.rect.right < ct.width*0.7 and random.randrange(0,50) == 10:
last_obstacle.empty()
last_obstacle.add(Cactus(self.screen,gamespeed, 40, 40))
if len(pteras) == 0 and random.randrange(0,200) == 10 and counter > 500:
for l in last_obstacle:
if l.rect.right < ct.width*0.8:
last_obstacle.empty()
last_obstacle.add(Ptera(self.screen,gamespeed, 46, 40))
if len(clouds) < 5 and random.randrange(0,300) == 10:
Cloud(self.screen,ct.width,random.randrange(ct.height/5,ct.height/2))
playerDino.update()
cacti.update()
pteras.update()
clouds.update()
new_ground.update()
scb.update(playerDino.score)
highsc.update(self.high_score)
if pg.display.get_surface() != None:
self.screen.fill(ct.background_col)
new_ground.draw()
clouds.draw(self.screen)
scb.draw()
if self.high_score != 0:
highsc.draw()
self.screen.blit(HI_image,HI_rect)
cacti.draw(self.screen)
pteras.draw(self.screen)
playerDino.draw()
pg.display.update()
self.clock.tick(ct.FPS)
if playerDino.isDead:
gameOver = True
if playerDino.score > self.high_score:
self.high_score = playerDino.score
if counter%700 == 699:
new_ground.speed -= 1
gamespeed += 1
counter = (counter + 1)
if gameQuit:
break
while gameOver:
if pg.display.get_surface() == None:
print("Couldn't load display surface")
gameQuit = True
gameOver = False
else:
for event in pg.event.get():
if event.type == pg.QUIT:
gameQuit = True
gameOver = False
if event.type == pg.KEYDOWN:
if event.key == pg.K_ESCAPE:
gameQuit = True
gameOver = False
if event.key == pg.K_RETURN or event.key == pg.K_SPACE:
gameOver = False
self.gameplay()
highsc.update(self.high_score)
if pg.display.get_surface() != None:
self.disp_gameOver_msg(retbutton_image,gameover_image)
if self.high_score != 0:
highsc.draw()
self.screen.blit(HI_image,HI_rect)
pg.display.update()
self.clock.tick(ct.FPS)
pg.quit()
self.cam.stop()
quit()
"""
Simple tester for the vgg19_trainable
"""
# import utils
# import os, os.path
# path = "/vgg19/train"
# for f in os.listdir(path):
# img1 = utils.load_image("./test_data/tiger.jpeg")
import glob
import utils
import numpy as np
img_arr = []
i = 0
for filename in glob.glob('all_tests/*.jpg'):
img = utils.load_image(filename)
img_arr.append(img)
i = i + 1
print(i)
np.save('test.npy', img_arr)
def init(): # called by run()
random.seed()
global redraw
global screen, w, h, font1, font2, font3, clock
global factor, offset, imgf, message, version_display
global pos, pointer
redraw = True
version_display = False
screen = pygame.display.get_surface()
pygame.display.set_caption(app)
screen.fill((255, 255, 192))
pygame.display.flip()
w, h = screen.get_size()
if float(w) / float(h) > 1.5: #widescreen
offset = (w - 4 * h / 3) / 2 # we assume 4:3 - centre on widescreen
else:
h = int(.75 * w) # allow for toolbar - works to 4:3
offset = 0
factor = float(h) / 24 # measurement scaling factor (32x24 = design units)
imgf = float(
h) / 900 # image scaling factor - all images built for 1200x900
clock = pygame.time.Clock()
if pygame.font:
t = int(60 * imgf)
font1 = pygame.font.Font(None, t)
t = int(80 * imgf)
font2 = pygame.font.Font(None, t)
t = int(40 * imgf)
font3 = pygame.font.Font(None, t)
message = ''
pos = pygame.mouse.get_pos()
pointer = utils.load_image('pointer.png', True)
pygame.mouse.set_visible(False)
# this activity only
global level, best, bgd, x0, message_c, scores, scores_c
global score, target, score_c, target_c, vinc, percent, percent_xy, best_xy
global glow, ms
global help_img, help_on, help_cxy
global count, count_c, complete
best = 0
bgd = utils.load_image('bgd.png', False)
x0 = sx(0)
message_c = (sx(16), sy(2))
scores = utils.load_image('scores.png', False)
scores_c = (sx(5.7), sy(11))
score = 0
target = 0
y = 1.18 - .3
score_c = (sx(1.8), sy(y))
target_c = (sx(1.8), sy(y + 1.32))
vinc = pygame.Rect(sx(1.17), sy(y + .52), sy(1.3), sy(.16))
percent = None
percent_xy = (sx(2.9), sy(y + .08))
best_xy = (sx(25.5), sy(y - .5))
glow = utils.load_image('glow.png', True)
ms = None
help_img = utils.load_image('help.png', False)
help_cxy = (sx(16), sy(10.1))
help_on = False
count = 0
count_c = (sx(28.5), best_xy[1] + sy(1.4))
complete = False
def init(): # called by run()
global redraw
global screen, w, h, font1, font2, clock
global factor, offset, imgf, message, version_display
global pos, pointer
redraw = True
version_display = False
screen = pygame.display.get_surface()
pygame.display.set_caption(app)
screen.fill((70, 0, 70))
pygame.display.flip()
w, h = screen.get_size()
if float(w) / float(h) > 1.5: #widescreen
offset = (w - 4 * h / 3) / 2 # we assume 4:3 - centre on widescreen
else:
h = int(.75 * w) # allow for toolbar - works to 4:3
offset = 0
clock = pygame.time.Clock()
factor = float(h) / 24 # measurement scaling factor (32x24 = design units)
imgf = float(
h) / 900 # image scaling factor - all images built for 1200x900
if pygame.font:
t = int(144 * imgf)
font1 = pygame.font.Font(None, t)
t = int(96 * imgf)
font2 = pygame.font.Font(None, t)
message = ''
pos = pygame.mouse.get_pos()
pointer = utils.load_image('pointer.png', True)
pygame.mouse.set_visible(False)
# this activity only
global wizard, xo, won, lost, x0, y0, dd, ww, sq, grid_img, grid, current, state
global magician, xo2, magician_grey, xo2_grey, glow_h, glow_v, yes, no, result
# (x0,y0) top left of grid
dd = sy(3.76)
ww = sy(.24) # line width
x0 = sx(16) - 2.5 * dd - ww / 2
y0 = sy(1.5)
won = 0
lost = 0
wizard = utils.load_image('wizard.png', True)
xo = utils.load_image('xo.png', True)
xo2 = utils.load_image('xo2.png', True)
magician_grey = utils.load_image('magician_grey.png', True)
xo2_grey = utils.load_image('xo2_grey.png', True)
magician = utils.load_image('magician.png', True)
sq = utils.load_image('sq.png', True)
grid_img = utils.load_image('grid.png', True)
glow_h = utils.load_image('glow_h.png', True)
glow_v = utils.load_image('glow_v.png', True)
yes = utils.load_image('yes.png', True)
no = utils.load_image('no.png', True)
result = None
grid = grid.Grid()
current = 1 # 1=player 2=PC
state = 0
#coding:utf-8
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
import vgg16
import utils
from Nclasses import labels
img_path = str(input('Input the path and image name:'))
img_ready = utils.load_image(img_path) #调入图像,对测试图像进行预处理
fig = plt.figure(u"Top-5 预测结果")
with tf.Session() as sess:
images = tf.placeholder(tf.float32, [1, 224, 224, 3])
vgg = vgg16.Vgg16()
vgg.forward(images) #前向传播的过程
#输入测试图像,完成前向传播过程
probability = sess.run(vgg.prob, feed_dict={images: img_ready})
top5 = np.argsort(probability[0])[-1:-6:-1]
print("top5:", top5)
values = []
bar_label = []
#输出概率组大的五种可能性,并且和标签一一列举
for n, i in enumerate(top5):
print("n:", n)
print("i:", i)
values.append(probability[0][i])
bar_label.append(labels[i])
#属于这个类别的概率
print(i, ":", labels[i], "----", utils.percent(probability[0][i]))
def __getitem__(self, index):
idx = self.ids[index]
X = load_image('Datasets/VGG_Cell_Dataset/%03dcell.png') / 255
Y = load_image('Datasets/VGG_Cell_Dataset/%03ddots.png') / 255
return X, y
def init(): # called by main()
global redraw
global screen, w, h, font1, font2, clock
global factor, offset, imgf, message, version_display
global pos, pointer
redraw = True
version_display = False
screen = pygame.display.get_surface()
pygame.display.set_caption(app)
screen.fill((70, 0, 70))
pygame.display.flip()
w, h = screen.get_size()
if float(w) / float(h) > 1.5: # widescreen
offset = (w - 4 * h / 3) / 2 # we assume 4:3 - centre on widescreen
else:
h = int(.75 * w) # allow for toolbar - works to 4:3
offset = 0
clock = pygame.time.Clock()
factor = float(h) / 24 # measurement scaling factor (32x24 = design units)
imgf = float(h) / 900 # image scaling factor - images built for 1200x900
if pygame.font:
t = int(64 * imgf)
font1 = pygame.font.Font(None, t)
t = int(72 * imgf)
font2 = pygame.font.Font(None, t)
message = ''
pos = pygame.mouse.get_pos()
pointer = utils.load_image('pointer.png', True)
pygame.mouse.set_visible(False)
# this activity only
global sp, sp1, sp2
global nos_k, signs, max_n, buffr, aim, top, level, score, best, best_c
global magician, sparkle, target, smiley, plus, times, equals, n
global n_glow, n_pale
global xy1, cxy2, xy3, offset1, offset2, state
sp = sy(.3) # space between digits in single number
sp1 = sy(2) # space between numbers
sp2 = sy(1.5) # space between numbers and symbols
nos_k = 3 # number of numbers offered
signs = ('=', '+', '*')
max_n = 5 # biggest number
buffr = []
aim = 0
top = []
level = 1
score = 0
best = 0
equals = utils.load_image('equals.png', True)
magician = utils.load_image('magician.png', True)
sparkle = utils.load_image('sparkle.png', True)
target = utils.load_image('target.png', True)
smiley = utils.load_image('smiley.png', True)
plus = utils.load_image('plus.png', True)
times = utils.load_image('times.png', True)
best_c = (sx(10.6), sy(20.2))
n = [] # 0 to 9 images
n_glow = [] # ... with glow
n_pale = []
for i in range(10):
img = utils.load_image(str(i) + '.png', True)
n.append(img)
img = utils.load_image(str(i) + 'g.png', True)
n_glow.append(img)
img = utils.load_image(str(i) + 's.png', True)
n_pale.append(img)
xy1 = sx(3), sy(3.0)
cxy2 = sx(4), sy(10)
xy3 = sx(3), sy(13)
ph2 = pointer.get_height() / 2
offset1 = n[1].get_width() / 2, n[0].get_height() - ph2
offset2 = 0, ph2
state = 1 # 1 = top line; 2 = ops line; 3 = wrong; 4 = right
vgg.y = tf.nn.softmax(vgg.fc9, name='result')
loss = tf.reduce_sum((vgg.y - y_)**2)
train = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)
saver = tf.train.Saver(max_to_keep=500)
train_batch = np.zeros((batch_size, 224, 224, 3), dtype=np.float32)
batch_models = batch_size / model_views
labels = np.zeros((batch_models, class_nums), dtype=int)
perm = np.arange(train_models)
num_batches = train_models*model_views / batch_size
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
saver.restore(sess, './train_models/batch_size_60_epo_8_total_v2.ckpt')
for epo in range(epoch):
np.random.shuffle(perm)
for i in range(num_batches):
for j in range(batch_models):
num = i*batch_models + j
for k in range(model_views):
train_batch[j*model_views + k] = utils.load_image(train_path + train_files[perm[num]*model_views + k])
labels[j] = train_labels[perm[num]]
_,cost_compute = sess.run([train,loss], feed_dict={images:train_batch, y_:labels, train_mode:True})
print('step %d,loss %f' % (i, cost_compute))
if epo > 0:
saver.save(sess, "./train_models/batch_size_{}_epo_{}_total_v2.ckpt".format(batch_size, epo+8))
from engine import hamming_dist, cosine_dist
from prototype import Hashnet
from utils import load_image
if __name__ == "__main__":
p1 = load_image('/Users/ethan/Desktop/p1.png')
p2 = load_image('/Users/ethan/Desktop/p2.png')
print("loading model")
engine = Hashnet()
engine.load('models/hashnet.h5')
print("extracting features")
a = engine.extract_features(p1, p2)
codes, features = a
print(codes.shape, features.shape)
hamming = hamming_dist(codes[[0]], codes[[1]])
similarity = cosine_dist(features[[0]], features[[1]])
print(hamming, similarity)
import numpy as np
import tensorflow as tf
import vgg16
import utils
img1 = utils.load_image("./test_data/tiger.jpeg")
img2 = utils.load_image("./test_data/puzzle.jpeg")
batch1 = img1.reshape((1, 224, 224, 3))
batch2 = img2.reshape((1, 224, 224, 3))
batch = np.concatenate((batch1, batch2), 0)
with tf.Session(config=tf.ConfigProto(gpu_options=(tf.GPUOptions(
per_process_gpu_memory_fraction=0.7)))) as sess:
images = tf.placeholder("float", [2, 224, 224, 3])
feed_dict = {images: batch}
vgg = vgg16.Vgg16()
with tf.name_scope("content_vgg"):
vgg.build(images)
print(vgg.pool1.shape)
print(vgg.pool2.shape)
print(vgg.pool3.shape)
print(vgg.pool4.shape)
print(vgg.pool5.shape)
print(vgg.fc6.shape)
print(vgg.fc7.shape)
print(vgg.fc8.shape)
def main():
# parse arguments
args = parse_args()
if args is None:
exit()
# initiate VGG19 model
model_file_path = args.model_path + '/' + vgg19.MODEL_FILE_NAME
vgg_net = vgg19.VGG19(model_file_path)
# load content image and style image
content_image = utils.load_image(args.content, max_size=args.max_size)
style_image = utils.load_image(args.style, shape=(content_image.shape[1],content_image.shape[0]))
# initial guess for output
if args.initial_type == 'content':
init_image = content_image
elif args.initial_type == 'style':
init_image = style_image
elif args.initial_type == 'random':
init_image = np.random.normal(size=content_image.shape, scale=np.std(content_image))
# check input images for style-transfer
# utils.plot_images(content_image,style_image, init_image)
# create a map for content layers info
CONTENT_LAYERS = {}
for layer, weight in zip(args.content_layers,args.content_layer_weights):
CONTENT_LAYERS[layer] = weight
# create a map for style layers info
STYLE_LAYERS = {}
for layer, weight in zip(args.style_layers, args.style_layer_weights):
STYLE_LAYERS[layer] = weight
# open session
sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))
# build the graph
st = style_transfer.StyleTransfer(session = sess,
content_layer_ids = CONTENT_LAYERS,
style_layer_ids = STYLE_LAYERS,
init_image = add_one_dim(init_image),
content_image = add_one_dim(content_image),
style_image = add_one_dim(style_image),
net = vgg_net,
num_iter = args.num_iter,
loss_ratio = args.loss_ratio,
content_loss_norm_type = args.content_loss_norm_type,
)
# launch the graph in a session
result_image = st.update()
# close session
sess.close()
# remove batch dimension
shape = result_image.shape
result_image = np.reshape(result_image,shape[1:])
# save result
utils.save_image(result_image,args.output)
"""
Simple tester for the vgg19_trainable
"""
import tensorflow as tf
import vgg19_trainable as vgg19
import utils
img1 = utils.load_image("./test_data/tiger.jpeg")
# 1-hot result for tiger
img1_true_result = [1 if i == 292 else 0 for i in xrange(1000)]
batch1 = img1.reshape((1, 224, 224, 3))
with tf.device('/cpu:0'):
sess = tf.Session()
images = tf.placeholder(tf.float32, [1, 224, 224, 3])
true_out = tf.placeholder(tf.float32, [1, 1000])
train_mode = tf.placeholder(tf.bool)
vgg = vgg19.Vgg19('./vgg19.npy')
vgg.build(images, train_mode)
# number of variables used: 143667240 variables, i.e. ideal size = 548MB
print vgg.get_var_count()
sess.run(tf.initialize_all_variables())
# test classification
import utils
with open("vgg16.tfmodel", mode='rb') as f:
fileContent = f.read()
graph_def = tf.GraphDef()
graph_def.ParseFromString(fileContent)
images = tf.placeholder("float", [None, 224, 224, 3])
tf.import_graph_def(graph_def, input_map={"images": images})
print("graph loaded from disk")
graph = tf.get_default_graph()
cat = utils.load_image("cat.jpg")
with tf.Session() as sess:
init = tf.global_variables_initializer()
sess.run(init)
print("variables initialized")
batch = cat.reshape((1, 224, 224, 3))
assert batch.shape == (1, 224, 224, 3)
feed_dict = {images: batch}
prob_tensor = graph.get_tensor_by_name("import/prob:0")
prob = sess.run(prob_tensor, feed_dict=feed_dict)
sess.close()
# Load image and sample mask #
##############################
shape = (256, 256)
params = {
'maxit': 500,
'Lips': 1,
'lambda': 0.01,
'x0': np.zeros((shape[0] * shape[1], 1)),
'shape': shape,
'verbose': True,
'm': shape[0],
'rate': 0.4,
'N': shape[0] * shape[1]
}
PATH = 'data/me.jpg'
image = load_image(PATH, params['shape'])
im_us, mask = apply_random_mask(image, params['rate'])
indices = np.nonzero(mask.flatten(order='F'))[0]
params['indices'] = indices
# Section (a): Comparison with 500 iterations
im_l1, time_l1 = reconstruct_l1(image, indices, FISTA, params)
plot_performance(image, im_us, im_l1, time_l1, 'L1')
im_tv, time_tv = reconstruct_TV(image, indices, FISTA, params)
plot_performance(image, im_us, im_tv, time_tv, 'TV')
# Section (b): Comparison with 5 iterations
params['maxit'] = 5
im_l1, time_l1 = reconstruct_l1(image, indices, FISTA, params)
plot_performance(image, im_us, im_l1, time_l1, '5 iterations L1')
os.makedirs(perimage_folder + 'magnified')
os.makedirs(perimage_folder + 'difference12')
os.makedirs(perimage_folder + 'difference20')
#os.makedirs(perimage_folder+'direction')
with open(perimage_folder + '%s.txt' % (video), 'w') as txt:
txt.write('Video: %s\n' % video)
for f, fr in enumerate(frame):
txt.write('Frame: %d\n' % (fr))
for nn in healthy_nn[f]:
txt.write('%s %d\n' %
(h_pos_videos_se[nn], h_pos_frames_sel[nn]))
for f, fr in enumerate(tqdm(frame)):
healthy_seq = [
load_image(cfg.crops_path, h_pos_videos_se[nn],
h_pos_frames_sel[nn]) for nn in healthy_nn[f]
]
impaired_seq = [
load_image(cfg.crops_path, i_pos_videos[nn], i_pos_frames[nn])
for nn in impaired_nn[f]
]
healthy_res, impaired_res, magnified_res = generator.extrapolate_multiple(
healthy_seq, h_pos_feat_sel[healthy_nn[f]], impaired_seq,
i_pos_feat[impaired_nn[f]], [0.0, 1.0, args.lambdas])
diff_image12, flow_filtered, X, Y, _ = find_differences_cc(
healthy_res, impaired_res, magnified_res, Th=0.12, scale=20)
diff_image20, flow_filtered, X, Y, _ = find_differences_cc(
healthy_res, impaired_res, magnified_res, Th=0.20, scale=20)
#plt.figure()
#plt.imshow(impaired_res); _=subplot[4][f].axis('Off')
#plt.quiver(X, Y, flow_filtered[:,0],flow_filtered[:,1], width=0.1,
conf.output_dir = utils.abspath(conf.output_dir)
# load network architecture module
architecture = utils.load_module(conf.model)
# get max_samples_training random training samples
n_inputs = len(conf.input_training)
files_train_input = [
utils.get_files_in_folder(folder) for folder in conf.input_training
]
files_train_label = utils.get_files_in_folder(conf.label_training)
_, idcs = utils.sample_list(files_train_label,
n_samples=conf.max_samples_training)
files_train_input = [np.take(f, idcs) for f in files_train_input]
files_train_label = np.take(files_train_label, idcs)
image_shape_original_input = utils.load_image(
files_train_input[0][0]).shape[0:2]
image_shape_original_label = utils.load_image(files_train_label[0]).shape[0:2]
print(f"Found {len(files_train_label)} training samples")
# get max_samples_validation random validation samples
files_valid_input = [
utils.get_files_in_folder(folder) for folder in conf.input_validation
]
files_valid_label = utils.get_files_in_folder(conf.label_validation)
_, idcs = utils.sample_list(files_valid_label,
n_samples=conf.max_samples_validation)
files_valid_input = [np.take(f, idcs) for f in files_valid_input]
files_valid_label = np.take(files_valid_label, idcs)
print(f"Found {len(files_valid_label)} validation samples")
# parse one-hot-conversion.xml
def current_frame_image(self, index):
print(f'Timeline::current_frame_index({index})')
return utils.load_image(self.image_sources[index], numpy.ndarray)
args = get_args()
images_paths = get_images_paths_to_deblur(args)
deblurNN = create_network(args)
n = len(images_paths)
total_deblur_time = 0
pbar = tqdm(images_paths, total=n)
print('\n\n*********************************************************')
print(f'Saving results to {os.path.realpath(args.out_dir)}')
print('*********************************************************\n\n')
for i, image_path in enumerate(pbar):
pbar.set_description_str(f'Deblurring image {os.path.basename(image_path)}')
blurry_image = utils.load_image(image_path)
t = time.time()
# the result image is a float image in range 0-255
deblurred_image_float = deblurNN.deblur(blurry_image)
# the first image usually takes much longer (due to libraries loading and similar stuff) so we discard its time
if i == 0:
total_deblur_time += time.time() - t
deblurred_image = np.round(deblurred_image_float).astype(np.uint8)
out_image = deblurred_image
if args.side_by_side:
out_image = np.concatenate([blurry_image, deblurred_image], axis=1)
utils.save_image(create_output_filename(args, image_path), out_image)
def __init__(self, path, position):
pygame.sprite.Sprite.__init__(self)
self.image = load_image(path).convert_alpha()
self.position = position
if os.path.splitext(test_label_file)[0].split(
"/")[-1] == text_classes[cls_i]:
class_code = [1 if j == cls_i else 0 for j in range(num_classes)]
with open(test_label_file, "r") as f:
lines = f.readlines()
for line in lines:
test_image_file_name = line.strip("\n")
print(test_image_file_name)
test_image_file_label_index[test_image_file_name] = class_code
# print(test_image_file_name, class_code)
# load all test images
#print (test_image_file_label_index)
for test_image_file_name in os.listdir(path_dataset + "test"):
if test_image_file_name.startswith('.'):
continue
test_image = utils.load_image(path_dataset + "test/" +
test_image_file_name)
test_dataset_images.append(test_image)
#print("load test image:", test_image.shape, test_image_file_name)
#print(test_image_file_name, test_image_file_label_index[test_image_file_name])
test_dataset_labels.append(
test_image_file_label_index[test_image_file_name])
# convert list into array
#print (test_dataset_labels)
test_dataset_images = np.array(test_dataset_images)
test_dataset_labels = np.array(test_dataset_labels)
#lb = preprocessing.LabelBinarizer()
#test_dataset_labels = lb.fit_transform(test_dataset_labels)
# reshape for tensor
test_dataset_images = test_dataset_images.reshape((num_test_size, 224, 224, 3))
if __name__ == '__main__':
def __init__(self, content_layer_ids, style_layer_ids, content_images,
style_images, session, net, num_epochs, batch_size,
content_weight, style_weight, tv_weight, learn_rate,
save_path, check_period, test_image, max_size, style_name):
self.net = net
self.sess = session
self.style_name = style_name
# sort layers info
self.CONTENT_LAYERS = collections.OrderedDict(
sorted(content_layer_ids.items()))
self.STYLE_LAYERS = collections.OrderedDict(
sorted(style_layer_ids.items()))
# input images
self.x_list = content_images
mod = len(content_images) % batch_size
self.x_list = self.x_list[:-mod]
self.y_list = style_images
self.content_size = len(self.x_list)
# parameters for optimization
self.num_epochs = num_epochs
self.content_weight = content_weight
self.style_weight = style_weight
self.tv_weight = tv_weight
self.learn_rate = learn_rate
self.batch_size = batch_size
self.check_period = check_period
# path for model to be saved
self.save_path = save_path
# image transform network
self.transform = Transform(len(self.y_list))
self.tester = Transform(len(self.y_list), 'test')
# build graph for style transfer
self._build_graph()
# test during training
if test_image is not None:
self.TEST = True
# load content image
self.test_image = load_image(test_image, max_size=max_size)
# build graph
self.x_test = tf.placeholder(tf.float32,
shape=self.test_image.shape,
name='test_input')
self.xi_test = tf.expand_dims(self.x_test,
0) # add one dim for batch
self.style_index_test = tf.placeholder(tf.int32,
shape=(1, ),
name='test_style_index')
self.style_index_test_batch = tf.expand_dims(
self.style_index_test, 0)
# result image from transform-net
self.y_hat_test = self.tester.net(
self.xi_test / 255.0, self.style_index_test_batch
) # please build graph for train first. tester.net reuses variables.
else:
self.TEST = False
def get_pb(self, path):
thumbs = glob(os.path.join(path, "thumb.*"))
thumbs.extend(glob(os.path.join(self.path, "default_thumb.*")))
thumbs = filter(lambda x: os.path.exists(x), thumbs)
thumbs.append(None)
return load_image(thumbs[0], THUMB_SIZE, THUMB_SIZE)
def train(self):
""" define optimizer Adam """
global_step = tf.contrib.framework.get_or_create_global_step()
trainable_variables = tf.trainable_variables()
grads = tf.gradients(self.L_total, trainable_variables)
optimizer = tf.train.AdamOptimizer(self.learn_rate)
train_op = optimizer.apply_gradients(zip(grads, trainable_variables),
global_step=global_step,
name='train_step')
""" session run """
self.sess.run(tf.global_variables_initializer())
# saver to save model
saver = tf.train.Saver()
current_style_num = 1
""" loop for train """
num_examples = len(self.x_list)
# get iteration info
epoch = 0
iterations = 0
try:
while epoch < self.num_epochs:
while iterations * self.batch_size < num_examples:
if current_style_num > len(self.y_list):
current_style_num = 1
curr = iterations * self.batch_size
step = curr + self.batch_size
x_batch = np.zeros(self.batch_shape, dtype=np.float32)
for j, img_p in enumerate(self.x_list[curr:step]):
x_batch[j] = get_img(img_p,
(256, 256, 3)).astype(np.float32)
iterations += 1
assert x_batch.shape[0] == self.batch_size
_, L_total, L_content, L_style, L_tv, step = self.sess.run(
[
train_op, self.L_total, self.L_content,
self.L_style, self.L_tv, global_step
],
feed_dict={
self.y_c: x_batch,
self.y_s: self.y_list[current_style_num - 1],
self.style_index: np.array([current_style_num - 1])
})
print(
'epoch : %d, iter : %4d, ' % (epoch, step),
'L_total : %g, L_content : %g, L_style : %g, L_tv : %f'
% (L_total, L_content, L_style, L_tv))
if step % self.check_period == 0:
res = saver.save(self.sess,
self.save_path + '/final.ckpt', step)
if self.TEST:
output_image = self.sess.run(
[self.y_hat_test],
feed_dict={
self.x_test:
self.test_image,
self.style_index_test:
np.array([current_style_num - 1])
})
output_image = np.squeeze(
output_image[0]) # remove one dim for batch
output_image = np.clip(output_image, 0., 255.)
save_image(
output_image, self.save_path + '/result_' +
"%05d" % step + '.jpg')
current_style_num += 1
epoch += 1
iterations = 0
except KeyboardInterrupt:
pass
finally:
saver = tf.train.Saver()
res = saver.save(self.sess, self.save_path + '/final.ckpt')
self.sess.close()
tf.reset_default_graph()
for image_size in (384, 512):
content_image = load_image(
'../input/examples/examples/content_img/content_2.png',
max_size=image_size)
# open session
soft_config = tf.ConfigProto(allow_soft_placement=True)
soft_config.gpu_options.allow_growth = True # to deal with large image
sess = tf.Session(config=soft_config)
# build the graph
transformer = StyleTransferTester(session=sess,
model_path=res,
content_image=content_image,
n_styles=len(self.y_list))
transformer.save_as_tflite('{}_{}'.format(
self.style_name, image_size))
print('Saved as tflite!')
sess.close()
tf.reset_default_graph()
content_paths.append(args.content_path)
if args.style_dir:
# use a batch of style images
style_paths = extract_image_names(args.style_dir)
else:
# use a single style image
style_paths.append(args.style_path)
print('Number content images:', len(content_paths))
print('Number style images:', len(style_paths))
with torch.no_grad():
for i in range(len(content_paths)):
content = load_image(content_paths[i])
content = preprocess(content, args.content_size)
content = content.to(device)
for j in range(len(style_paths)):
style = load_image(style_paths[j])
style = preprocess(style, args.style_size)
style = style.to(device)
if args.synthesis == 0:
output = style_transfer(content, style)
output = deprocess(output)
if len(content_paths) == 1 and len(style_paths) == 1:
# used a single content and style image
save_path = '%s/%s.%s' % (args.save_dir, args.save_name,
import numpy as np
import tensorflow as tf
import vgg16
import utils
import os
# create a list of images
path = './test_data/'
imlist = [
os.path.join(path, f) for f in os.listdir(path) if f.endswith('.jpg')
]
image_array = [
utils.load_image(img_path).reshape((1, 224, 224, 3)) for img_path in imlist
]
#for img_path in imlist:
#print(img_path)
#utils.load_image(img_path).reshape((1, 224, 224, 3))
#print("success")
#img1 = utils.load_image("./test_data/tiger.jpeg")
#img2 = utils.load_image("./test_data/puzzle.jpeg")
#batch1 = img1.reshape((1, 224, 224, 3))
#batch2 = img2.reshape((1, 224, 224, 3))
#batch = np.concatenate((batch1, batch2), 0)
batch = np.concatenate(image_array, 0)
# -*- coding: utf-8 -*-
import tensorflow as tf
import vgg19_trainable as vgg19
import utils
img1 = utils.load_image("./tiger.jpeg")
img1_true_result = [0, 1, 0, 0, 0] # 1-hot result for tiger
batch1 = img1.reshape((1, 224, 224, 3))
with tf.device('/cpu:0'):
sess = tf.Session()
images = tf.placeholder(tf.float32, [1, 224, 224, 3])
true_out = tf.placeholder(tf.float32, [1, 5])
train_mode = tf.placeholder(tf.bool)
vgg = vgg19.Vgg19()
vgg.build(images, train_mode)
print('build finished')
# print number of variables used: 143667240 variables, i.e. ideal size = 548MB
print(vgg.get_var_count())
sess.run(tf.global_variables_initializer())
# test classification
prob = sess.run(vgg.prob, feed_dict={images: batch1, train_mode: False})
print(prob)
# simple 1-step training
def load_val_batch(start, finish):
imgs = np.array([utils.load_image(i) for i in val_set[start:finish]])
labels = np.array([i for i in val_set_labels[start:finish]])
return imgs, labels
def __getitem__(self, idx):
X = utils.load_image(self.path[idx])
if self.transform:
X = self.transform(X)
y = self.target[idx]
return X, y
def train(args):
np.random.seed(args.seed)
torch.manual_seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)
transform = transforms.Compose([
transforms.Scale(args.image_size),
transforms.CenterCrop(args.image_size),
transforms.ToTensor(),
transforms.Lambda(lambda x: x.mul(255))
])
train_dataset = datasets.ImageFolder(args.dataset, transform)
train_loader = DataLoader(train_dataset, batch_size=args.batch_size)
transformer = TransformerNet(args.shiftnet)
optimizer = Adam(transformer.parameters(), args.lr)
mse_loss = torch.nn.MSELoss()
vgg = Vgg16(requires_grad=False)
style_transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Lambda(lambda x: x.mul(255))])
style = utils.load_image(args.style_image, size=args.style_size)
style = style_transform(style)
style = style.repeat(args.batch_size, 1, 1, 1)
if args.cuda:
transformer.cuda()
vgg.cuda()
style = style.cuda()
style_v = Variable(style)
style_v = utils.normalize_batch(style_v)
features_style = vgg(style_v)
gram_style = [utils.gram_matrix(y) for y in features_style]
for e in range(args.epochs):
transformer.train()
agg_content_loss = 0.
agg_style_loss = 0.
count = 0
for batch_id, (x, _) in enumerate(train_loader):
n_batch = len(x)
count += n_batch
optimizer.zero_grad()
x = Variable(x)
if args.cuda:
x = x.cuda()
y = transformer(x)
y = utils.normalize_batch(y)
x = utils.normalize_batch(x)
features_y = vgg(y)
features_x = vgg(x)
content_loss = args.content_weight * mse_loss(
features_y.relu2_2, features_x.relu2_2)
style_loss = 0.
for ft_y, gm_s in zip(features_y, gram_style):
gm_y = utils.gram_matrix(ft_y)
style_loss += mse_loss(gm_y, gm_s[:n_batch, :, :])
style_loss *= args.style_weight
total_loss = content_loss + style_loss
total_loss.backward()
optimizer.step()
agg_content_loss += content_loss.data[0]
agg_style_loss += style_loss.data[0]
if (batch_id + 1) % args.log_interval == 0:
mesg = "{}\tEpoch {}:\t[{}/{}]\tcontent: {:.6f}\tstyle: {:.6f}\ttotal: {:.6f}".format(
time.ctime(), e + 1, count, len(train_dataset),
agg_content_loss / (batch_id + 1),
agg_style_loss / (batch_id + 1),
(agg_content_loss + agg_style_loss) / (batch_id + 1))
print(mesg)
if args.checkpoint_model_dir is not None and (
batch_id + 1) % args.checkpoint_interval == 0:
transformer.eval()
if args.cuda:
transformer.cpu()
ckpt_model_filename = "ckpt_epoch_" + str(
e) + "_batch_id_" + str(batch_id + 1) + ".pth"
ckpt_model_path = os.path.join(args.checkpoint_model_dir,
ckpt_model_filename)
torch.save(transformer.state_dict(), ckpt_model_path)
if args.cuda:
transformer.cuda()
transformer.train()
# save model
transformer.eval()
if args.cuda:
transformer.cpu()
save_model_filename = "epoch_" + str(args.epochs) + "_" + str(
time.ctime()).replace(' ', '_') + "_" + str(
args.content_weight) + "_" + str(args.style_weight)
if args.shiftnet:
save_model_filename += "_shiftnet"
save_model_filename += ".model"
save_model_path = os.path.join(args.save_model_dir, save_model_filename)
torch.save(transformer.state_dict(), save_model_path)
print("\nDone, trained model saved at", save_model_path)
