def open_url(screen, img):
gl.ISURL = 1
num_imgs = len(gl.files)
paint_screen(screen, gl.BLACK)
set_caption("Extract from Web - imgv")
normal_cursor()
show_message(screen, "Enter a Web URL to extract images from", 20, 15, ("transparent"))
gl.URL = ask(screen, "http://")
if gl.URL != None:
gl.files = []
wait_cursor()
show_message(screen, "Loading. Please wait..", 39, 42, ("transparent"))
for ext in gl.IMG_TYPES:
if gl.URL.endswith(ext):
gl.files.append(str("".join(gl.URL)))
return (load_img(gl.files[0], screen), 1)
else:
return (img, num_imgs)
gl.files = []
check_indexhtml()
if gl.URL_ERROR:
gl.files.append(gl.ERROR_IMG)
return (load_img(gl.ERROR_IMG, screen), len(gl.files))
if len(gl.files) < 1:
gl.files.append(gl.ERROR_IMG)
gl.files = [x.replace(" ", "%20") for x in gl.files] # urls need %20 for spaces
return (load_img(gl.files[0], screen), len(gl.files))
def square_four(screen, file):
wait_cursor()
draw_lines(screen)
num_imgs = len(gl.files)
if file >= num_imgs or file <= 0:
file = 0
img_four_name = gl.files[file]
img_four_file = file
img_four = load_img(img_four_name, screen, 0)
file = file + 1
img_four = adjust_img_size(img_four, screen.get_width(), screen.get_height())
img_four_rect = img_four.get_rect()
img_four_rect[0] = (screen.get_width() / 2)
img_four_rect[1] = (screen.get_height() / 2)
screen.blit(img_four, img_four_rect)
update(img_four_rect)
draw_lines(screen)
if gl.FOUR_STATUS_BARS:
font_size = 9
font = pygame.font.Font(gl.FONT_NAME, font_size)
name = os.path.basename(img_four_name)
name = check_truncate(screen.get_width(), name)
img_status = "%s [%d/%d]" % (name, img_four_file + 1, num_imgs)
raise_up = 12
show_message(screen, img_status, ((screen.get_width() / 2) + (screen.get_width() / 4 - font.size(img_status)[0]/2), screen.get_height() - raise_up), font_size, ("bold"))
normal_cursor()
return (file, img_four_rect, img_four_name, img_four_file)
def command_refresh(refresh_img, screen, files, file):
"reset image to its original state"
wait_cursor()
new_img = refresh_img
rect = get_center(screen, new_img)
cur_filename = ""
if len(gl.files) > 1:
cur_filename = gl.files[file]
else:
normal_cursor()
return (new_img, new_img, get_center(screen, new_img), file)
if gl.SHRUNK and len(gl.files) > 1:
# reload shrunk images to their true size
gl.SKIP_FIT = 1
refresh_img = load_img(gl.files[file])
rect = get_center(screen, refresh_img)
adjust_files(gl.SUBDIRS)
if cur_filename in gl.files:
file = gl.files.index(cur_filename) # go back if new images were loaded
my_update_screen(refresh_img, rect, file)
normal_cursor()
return (refresh_img, new_img, rect, file)
adjust_files(gl.SUBDIRS)
if cur_filename in gl.files and len(gl.files) > 1:
file = gl.files.index(cur_filename) # go back if new images were loaded
my_update_screen(refresh_img, rect, file)
normal_cursor()
return (new_img, new_img, get_center(screen, new_img), file)
def print_version(screen, screen_height):
imgvlogo = load_img(gl.IMGV_LOGO_SMALL, screen, False)
imgvlogo_rect = imgvlogo.get_rect()
imgvlogo_rect[0] = 5
imgvlogo_rect[1] = screen_height - 50
screen.blit(imgvlogo, imgvlogo_rect)
update(imgvlogo_rect)
msg = "Version %s" % gl.IMGV_VERSION
msg_font = pygame.font.Font(gl.FONT_NAME, 11)
msg_font.set_bold(1)
char = 0
i = 0
pygame.event.set_blocked(MOUSEMOTION)
while 1:
event = pygame.event.poll()
pygame.time.wait(1)
check_quit(event)
if char < len(msg):
if msg[char] != ' ': # don't delay on spaces
pygame.time.delay(75)
ren = msg_font.render(msg[char], 1, gl.RED) # one char at a time
ren_rect = ren.get_rect()
# center it
ren_rect[0] += (i + 7)
ren_rect[1] = screen_height - 15
screen.blit(ren, ren_rect)
i += ren.get_width() # make letters space evenly
char += 1
update(ren_rect)
else:
break
def change_box(screen, positions):
change_img = load_img(gl.CHANGE_BOX, False)
change_rect = change_img.get_rect()
change_rect[0] = positions[1]
change_rect[1] = positions[0]
screen.blit(change_img, change_rect)
update(change_rect)
return change_rect
def command_shuffle(new_img, img, screen, rect, file):
"randomize the images"
wait_cursor()
shuffle(gl.files)
new_img = load_img(gl.files[file])
rect = get_center(screen, new_img)
my_update_screen(new_img, rect, file)
normal_cursor()
return (new_img, new_img, new_img, rect)
def show_current_image(self, file):
self.current = load_img(gl.files[file], self.screen, False)
(self.current, img_width, img_height) = preview_img(self.screen, self.current)
current_rect = self.current.get_rect()
current_rect[0] = 15
current_rect[1] = self.prev_pic_row
self.screen.blit(self.current, current_rect)
update(current_rect)
img_border(self.screen, img_width, img_height, 15, self.prev_pic_row - 2)
def command_unshuffle(new_img, img, screen, rect, file):
"un-randomize the images"
was_on = gl.files[file]
wait_cursor()
gl.files.sort(lambda x, y: cmp(x.lower(), y.lower()))
file = gl.files.index(was_on)
new_img = load_img(gl.files[file])
rect = get_center(screen, new_img)
my_update_screen(new_img, rect, file)
normal_cursor()
return (new_img, new_img, new_img, rect, file)
def command_first_img(new_img, screen, file, num_imgs, rect):
"jump to the first image"
wait_cursor()
start = start_timer()
file = 0
new_img = load_img(gl.files[file], screen)
rect = get_center(screen, new_img)
ns = check_timer(start)
my_update_screen(new_img, screen, rect, file, num_imgs, ns)
normal_cursor()
return (new_img, new_img, new_img, file, rect)
def command_shuffle(new_img, img, screen, rect, file, num_imgs):
"randomize the images"
wait_cursor()
start = start_timer()
shuffle(gl.files)
new_img = load_img(gl.files[file], screen)
rect = get_center(screen, new_img)
ns = check_timer(start)
my_update_screen(new_img, screen, rect, file, num_imgs, ns)
normal_cursor()
return (new_img, new_img, new_img, rect)
def command_show_dirs(new_img, img, screen, rect, file):
(screen, before_winsize, not_accepted) = adjust_screen(screen)
set_caption("Directory Browser - imgv")
paint_screen(gl.BLACK)
file = show_dirs(screen, file)
wait_cursor()
num_imgs = len(gl.files)
if gl.ESCAPED != 1:
if num_imgs < 1 or len(gl.files) == 0:
gl.files = [gl.IMGV_LOGO]
num_imgs = 0
new_img = img = load_img(gl.files[file])
else:
new_img = load_img(gl.files[file])
screen = restore_screen(screen, before_winsize, not_accepted, new_img, file, rect)
rect = get_center(screen, new_img)
if gl.ESCAPED != 1:
my_update_screen(new_img, rect, file)
else:
my_update_screen(new_img, rect, file)
normal_cursor()
return (new_img, new_img, new_img, file, rect)
def draw(canvas):
img_1 = load_img('rocket_frame_1.txt')
img_2 = load_img('rocket_frame_2.txt')
images = [img_1, img_2]
symbol = '+*.:'
x, y = window.getmaxyx()
coroutines = [
blink(canvas, row=random.randint(0, x - 1), column=random.randint(0, y - 1), symbol=random.choice(symbol)) for
_
in range(50)]
coroutines.append(animate_spaceship(canvas=canvas, images=images))
while True:
for coroutine in coroutines.copy():
try:
coroutine.send(None)
except StopIteration:
coroutines.remove(coroutine)
break
time.sleep(0.2)
def command_play_list_options(screen, file):
paint_screen(gl.BLACK)
old_file = file
(file, msg) = play_list_options(screen, file)
if (msg != None and file != "rclicked" and file != "deleteit"):
play_list_options_msg(screen, msg)
if (file == "rclicked"):
edit_play_list(screen, msg)
file = old_file
if (file == "deleteit"):
delete_play_list(msg)
file = old_file
new_img = load_img(gl.files[file])
rect = get_center(screen, new_img)
my_update_screen(new_img, rect, file)
normal_cursor()
return (new_img, new_img, new_img, file, rect)
def command_img_names(screen, new_img, img, file, rect):
num_imgs = len(gl.files)
(screen, before_winsize, not_accepted) = adjust_screen(screen)
paint_screen(gl.BLACK)
normal_cursor()
gl.SORT_HIT = 0
(list_names, filename, x, my_string) = command_file_master(screen, gl.files,\
"(%d Images)" % len(gl.files), 15, 0, 1, 0)
wait_cursor()
screen = restore_screen(screen, before_winsize, not_accepted, new_img, file, rect)
if not filename == None:
if num_imgs > 1:
file = gl.files.index(filename)
new_img = load_img(gl.files[file])
rect = get_center(screen, new_img)
my_update_screen(new_img, rect, file)
normal_cursor()
rect = get_center(screen, new_img)
my_update_screen(new_img, rect, file)
return (new_img, new_img, new_img, file, rect)
def __init__(self):
init_screen()
wait_cursor()
self.gfx = {}
self.gfx['screen'] = pygame.display.set_mode(gl.DEFAULT_RES, RESIZABLE)
set_caption(gl.TITLE)
if gl.REMOTE == 1:
show_message("Loading image. Please wait..", 34, 42)
self.gfx['file'] = 0
if len(gl.files) < 1:
gl.files = [gl.IMGV_LOGO]
self.gfx['img'] = load_img(gl.files[self.gfx['file']])
wait_cursor()
self.gfx['refresh_img'] = self.gfx['img']
self.gfx['new_img'] = self.gfx['img']
self.gfx['rect'] = get_center(self.gfx['screen'], self.gfx['new_img'])
my_update_screen(self.gfx['new_img'], self.gfx['rect'], self.gfx['file'])
normal_cursor()
if gl.START_FULLSCREEN:
command_fullscreen()
my_update_screen(self.gfx['new_img'], self.gfx['rect'], self.gfx['file'])
self.minus1 = 0
self.minus2 = 0
self.last_rect = Rect(self.gfx['rect'])
def handle_keyboard(event, gfx, last_rect):
screen = gfx['screen']
rect = gfx['rect']
new_img = gfx['new_img']
img = gfx['img']
refresh_img = gfx['refresh_img']
file = gfx['file']
if hit_key(event, K_d):
gl.USING_SCROLL_MENU = 1
# save current things in case the user ESCAPES out of show_dirs()
gl.LAST_DIR = getcwd()
last_files = gl.files
(last_new_img, last_img, last_refresh_img, last_file,
last_rect) = (new_img, img, refresh_img, file, rect)
(new_img, img, refresh_img, file,
rect) = command_show_dirs(new_img, img, screen, rect, file)
# user ESCAPED from show_dirs, reset last values
if gl.ESCAPED:
gl.ADDED_DIR_NUMS = 0
(new_img, img, refresh_img, file, rect) = (last_new_img,
last_img, last_refresh_img, last_file, last_rect)
chdir(gl.LAST_DIR)
gl.files = last_files
gl.USING_SCROLL_MENU = 0
my_update_screen(new_img, rect, file)
else:
gl.REFRESH_IMG_COUNT = 0
gl.ESCAPED = 0
gl.USING_SCROLL_MENU = 0
if hit_key(event, K_i):
(new_img, img, refresh_img, file, rect) = command_img_names(screen, new_img, img, file, rect)
if hit_key(event, K_F1):
gl.CALC_ZOOM = 0
zoom_percent = gl.CURRENT_ZOOM_PERCENT
real_width = gl.REAL_WIDTH
command_help(screen, new_img, file, rect)
if gl.ESCAPED:
gl.CURRENT_ZOOM_PERCENT = zoom_percent
gl.REAL_WIDTH = real_width
gl.ESCAPED = 0
if hit_key(event, K_F2):
rect = command_640x480(new_img, file, rect)
normal_cursor()
if hit_key(event, K_F3):
rect = command_800x600(new_img, file, rect)
normal_cursor()
if hit_key(event, K_F4):
rect = command_1024x768(new_img, file, rect)
normal_cursor()
if hit_key(event, K_F5):
rect = command_1280x1024(new_img, file, rect)
normal_cursor()
if hit_key(event, K_F6):
screen = command_fullscreen()
rect = get_center(screen, new_img)
my_update_screen(new_img, rect, file)
normal_cursor()
if event.type == KEYDOWN: # alt+enter code
mods = pygame.key.get_mods()
if ((event.key == K_RETURN and mods & KMOD_ALT)):
screen = command_fullscreen()
rect = get_center(screen, new_img)
my_update_screen(new_img, rect, file)
if hit_key(event, K_F7):
gl.USING_SCROLL_MENU = 1
gl.CALC_ZOOM = 0
zoom_percent = gl.CURRENT_ZOOM_PERCENT
real_width = gl.REAL_WIDTH
rect = command_show_res_modes(screen, new_img, file, rect)
gl.CURRENT_ZOOM_PERCENT = zoom_percent
gl.REAL_WIDTH = real_width
gl.USING_SCROLL_MENU = 0
my_update_screen(new_img, rect, file)
normal_cursor()
if hit_key(event, K_s):
(new_img, img, refresh_img, rect) = command_shuffle(
new_img, img, screen, rect, file)
if hit_key(event, K_u):
(new_img, img, refresh_img, rect,
file) = command_unshuffle(new_img, img, screen, rect, file)
if event.type == KEYDOWN:
mods = pygame.key.get_mods()
if event.key == K_r and mods & KMOD_CTRL == 0:
if gl.CURRENT_ZOOM_PERCENT < gl.ZOOM_PERCENT_MAX:
gl.CALC_ZOOM = 0
(new_img, img, rect) = command_rotate_right(new_img, screen, file, rect)
else:
print "Can't rotate. Out of memory."
if event.type == KEYDOWN:
mods = pygame.key.get_mods()
if event.key == K_r and mods & KMOD_CTRL:
if gl.CURRENT_ZOOM_PERCENT < gl.ZOOM_PERCENT_MAX:
gl.CALC_ZOOM = 0
(new_img, img, rect) = command_rotate_left(new_img, screen, file, rect)
else:
print "Can't rotate. Out of memory."
if event.type == KEYDOWN:
mods = pygame.key.get_mods()
if event.key == K_p and mods & KMOD_CTRL == 0:
command_add_to_play_list(screen, gl.files[file])
gl.SORT_HIT = 0
my_update_screen(new_img, rect, file)
if event.type == KEYDOWN:
mods = pygame.key.get_mods()
if event.key == K_p and mods & KMOD_CTRL:
(new_img, new_img, new_img, file, rect) = command_play_list_options(screen, file)
gl.SORT_HIT = 0
if event.type == KEYDOWN:
mods = pygame.key.get_mods()
if event.key == K_x and mods & KMOD_CTRL == 0:
command_hide(screen, new_img, rect, file)
if event.type == KEYDOWN:
mods = pygame.key.get_mods()
if event.key == K_x and mods & KMOD_CTRL:
if get_config_val("ON_THE_FLY_EXIF_STATUS_BAR") == 1:
gl.ON_FLY_EXIF_STATUS_BAR ^= 1
gl.TOGGLE_STATUS_BAR ^= 1
my_update_screen(new_img, rect, file)
normal_cursor()
if event.type == KEYDOWN:
mods = pygame.key.get_mods()
if (event.key == K_MINUS or event.key == K_KP_MINUS) and mods & KMOD_CTRL == 0:
if gl.CURRENT_ZOOM_PERCENT < gl.ZOOM_PERCENT_MAX:
try:
(new_img, img, rect) = command_zoom_out(new_img, img, file, rect, "normal")
except:
print 'Out of memory.'
else:
print "Can't zoom out. Out of memory. Resetting the image."
gl.SKIP_FIT = 1
gl.ZOOM_EXP = 0
wait_cursor()
new_img = load_img(gl.files[file])
img = refresh_img = new_img
rect = get_center(screen, new_img)
my_update_screen(new_img, rect, file)
normal_cursor()
if event.type == KEYDOWN:
mods = pygame.key.get_mods()
if (event.key == K_MINUS or event.key == K_KP_MINUS) and mods & KMOD_CTRL:
try:
(new_img, img, rect) = command_zoom_out(new_img, img, file, rect, "double")
except:
print 'Out of memory.'
if event.type == KEYDOWN:
mods = pygame.key.get_mods()
if (event.key == K_EQUALS or event.key == K_KP_PLUS) and mods & KMOD_CTRL == 0:
# Zoom in only if there seems to be enough memory
if gl.CURRENT_ZOOM_PERCENT < gl.ZOOM_PERCENT_MAX:
try: # triple zoom crash protection
(new_img, img, rect) = command_zoom_in(new_img, img, file, rect, "normal")
except:
print 'Zoom max reached.'
else:
print 'Zoom max reached.'
if event.type == KEYDOWN: # ctrl+'+' code
mods = pygame.key.get_mods()
if (event.key == K_EQUALS or event.key == K_KP_PLUS) and (mods & KMOD_CTRL and mods & KMOD_ALT == 0):
if gl.CURRENT_ZOOM_PERCENT < gl.ZOOM_PERCENT_MAX:
try:
(new_img, img, rect) = command_zoom_in(new_img, img, file, rect, "double")
except:
print 'Zoom max reached.'
else:
print 'Zoom max reached.'
if event.type == KEYDOWN:
mods = pygame.key.get_mods()
if (event.key == K_EQUALS or event.key == K_KP_PLUS) and (mods & KMOD_CTRL and mods & KMOD_ALT):
try:
(new_img, img, rect) = command_zoom_in(new_img, new_img, file, rect, "scale2x")
except:
print 'Zoom max. Out of memory.'
if hit_key(event, K_DOWN):
pygame.event.set_allowed(MOUSEMOTION)
gl.MY_KEYDOWN = 1
gl.HAND_TOOL = 1
if hit_key(event, K_UP):
pygame.event.set_allowed(MOUSEMOTION)
gl.MY_KEYUP = 1
gl.HAND_TOOL = 1
if hit_key(event, K_RIGHT):
pygame.event.set_allowed(MOUSEMOTION)
gl.MY_KEYRIGHT = 1
gl.HAND_TOOL = 1
if hit_key(event, K_LEFT):
pygame.event.set_allowed(MOUSEMOTION)
gl.MY_KEYLEFT = 1
gl.HAND_TOOL = 1
if hit_key(event, K_HOME):
pygame.event.set_allowed(MOUSEMOTION)
command_full_right(rect, last_rect, new_img, file)
if gl.IMG_BORDER:
img_border(new_img, rect)
if hit_key(event, K_END):
pygame.event.set_allowed(MOUSEMOTION)
command_full_left(rect, last_rect, new_img, file)
if gl.IMG_BORDER:
img_border(new_img, rect)
if hit_key(event, K_PAGEDOWN):
pygame.event.set_allowed(MOUSEMOTION)
command_full_up(rect, last_rect, new_img, file)
if gl.IMG_BORDER:
img_border(new_img, rect)
if hit_key(event, K_PAGEUP):
pygame.event.set_allowed(MOUSEMOTION)
command_full_down(rect, last_rect, new_img, file)
if gl.IMG_BORDER:
img_border(new_img, rect)
if hit_key(event, K_m):
(new_img, img, rect) = command_horiz(new_img, screen, file, rect)
if hit_key(event, K_v):
(new_img, img, rect) = command_vert(new_img, screen, file, rect)
if event.type == KEYDOWN:
mods = pygame.key.get_mods()
if (event.key == K_TAB and mods & KMOD_CTRL) or hit_key(event, K_SPACE) or\
hit_key(event, K_n):
(new_img, img, refresh_img, file,
rect) = command_next_img(new_img, screen, file, rect)
if event.type == KEYDOWN:
mods = pygame.key.get_mods()
if (hit_key(event, K_BACKSPACE) or hit_key(event, K_b)) and mods & KMOD_CTRL == 0:
(new_img, img, refresh_img, file,
rect) = command_prev_img(new_img, screen, file, rect)
if event.type == KEYDOWN:
mods = pygame.key.get_mods()
if event.key == K_b and mods & KMOD_CTRL:
gl.IMG_BORDER ^= 1
my_update_screen(new_img, rect, file)
normal_cursor()
if hit_key(event, K_o):
(screen, before_winsize, not_accepted) = adjust_screen(screen)
new_img = open_url(screen, img)
gl.URL_ERROR = False
file = 0
img = refresh_img = new_img
screen = restore_screen(
screen, before_winsize, not_accepted, new_img, file, rect)
rect = get_center(screen, new_img)
my_update_screen(new_img, rect, file)
normal_cursor()
if hit_key(event, K_ESCAPE):
(new_img, img, rect, file) = command_refresh(refresh_img, screen, gl.files, file)
my_update_screen(new_img, rect, file)
if event.type == KEYDOWN: # Ctrl+0 (Fit to Window) code
mods = pygame.key.get_mods()
if event.key == K_0 and mods & KMOD_CTRL:
gl.RESET_FIT = 0
gl.SCALE_UP = 1
if gl.FIT_IMAGE_VAL:
gl.RESET_FIT = 0
else:
gl.RESET_FIT = 1
gl.FIT_IMAGE_VAL = 1
wait_cursor()
new_img = load_img(gl.files[file])
img = refresh_img = new_img
rect = get_center(screen, new_img)
my_update_screen(new_img, rect, file)
if gl.RESET_FIT == 1:
gl.FIT_IMAGE_VAL = 0
normal_cursor()
if event.type == KEYDOWN: # Alt+0 (Actual Size) code
mods = pygame.key.get_mods()
if ((event.key == K_0 and mods & KMOD_ALT)):
gl.SKIP_FIT = 1
gl.ZOOM_EXP = 0
wait_cursor()
new_img = load_img(gl.files[file])
img = refresh_img = new_img
rect = get_center(screen, new_img)
my_update_screen(new_img, rect, file)
normal_cursor()
if hit_key(event, K_1) or hit_key(event, K_KP1):
#gl.SCALE_UP = 1
if gl.FIT_IMAGE_VAL:
gl.FIT_IMAGE_VAL = 0
gl.RESET_FIT = 1
else:
gl.SKIP_FIT = 0
gl.FIT_IMAGE_VAL = 1
gl.RESET_FIT = 0
wait_cursor()
if new_img.get_width() > screen.get_width() or new_img.get_height() > screen.get_height() or gl.RESET_FIT:
new_img = load_img(gl.files[file])
img = refresh_img = new_img
rect = get_center(screen, new_img)
if gl.RESET_FIT:
gl.FIT_IMAGE_VAL = 0
my_update_screen(new_img, rect, file)
normal_cursor()
if hit_key(event, K_f):
(new_img, img, refresh_img, file,
rect) = command_first_img(new_img, screen, file, rect)
if event.type == KEYDOWN:
mods = pygame.key.get_mods()
if (event.key == K_l and mods & KMOD_CTRL == 0):
(new_img, img, refresh_img, file,
rect) = command_last_img(new_img, screen, file, rect)
if event.type == KEYDOWN:
mods = pygame.key.get_mods()
if (event.key == K_l and mods & KMOD_CTRL):
gl.PERSISTENT_ZOOM_VAL ^= 1
if not gl.PERSISTENT_ZOOM_VAL:
gl.ZOOM_EXP = 0
my_update_screen(new_img, rect, file)
if event.type == KEYDOWN:
mods = pygame.key.get_mods()
if (event.key == K_DELETE and mods & KMOD_CTRL == 0) or\
(event.key == K_KP_PERIOD and mods & KMOD_CTRL == 0) or\
(event.key == K_w and mods & KMOD_CTRL):
(new_img, img, refresh_img, file,
rect) = command_remove_img(new_img, screen, file, rect)
if event.type == KEYDOWN:
mods = pygame.key.get_mods()
if (event.key == K_DELETE and mods & KMOD_CTRL) or\
(event.key == K_KP_PERIOD and mods & KMOD_CTRL):
fn = gl.files[file]
answer = get_confirmation(
screen, "Delete %s? [y/n]" % basename(fn))
if answer == "yes":
(new_img, img, refresh_img, file, rect) = command_delete_img(
fn, new_img, screen, file, rect)
my_update_screen(new_img, rect, file)
if event.type == KEYDOWN:
mods = pygame.key.get_mods()
if (event.key == K_w and mods & KMOD_CTRL == 0) and hit_key(event, K_w):
(new_img, img, refresh_img, file,
rect) = my_slideshow(new_img, img, screen, file, rect)
my_update_screen(new_img, rect, file)
if hit_key(event, K_e):
(screen, before_winsize, not_accepted) = adjust_screen(screen)
gl.USING_SCROLL_MENU = 1
zoom_percent = gl.CURRENT_ZOOM_PERCENT
real_width = gl.REAL_WIDTH
(new_img, img, refresh_img, file,
rect) = command_edit_menu(screen, file, new_img, rect)
if gl.ESCAPED:
gl.CURRENT_ZOOM_PERCENT = zoom_percent
gl.REAL_WIDTH = real_width
screen = restore_screen(screen, before_winsize, not_accepted, new_img, file, rect)
my_update_screen(new_img, rect, file)
gl.ESCAPED = 0
gl.USING_SCROLL_MENU = 0
if hit_key(event, K_z):
transparency = 0
if not gl.TOGGLE_TRANSPARENT:
gl.TOGGLE_TRANSPARENT = 1
transparency = 1
command_verbose_info(screen, new_img, rect, file)
if transparency:
gl.TOGGLE_TRANSPARENT = 0
my_update_screen(new_img, rect, file)
if hit_key(event, K_4):
gl.CALC_ZOOM = 0
zoom_percent = gl.CURRENT_ZOOM_PERCENT
real_width = gl.REAL_WIDTH
(file, new_img, img, refresh_img, rect) = command_four(screen, file, new_img)
if gl.ESCAPED:
gl.CURRENT_ZOOM_PERCENT = zoom_percent
gl.REAL_WIDTH = real_width
gl.ESCAPED = 0
my_update_screen(new_img, rect, file)
normal_cursor()
if event.type == KEYDOWN:
mods = pygame.key.get_mods()
if (event.key == K_t and mods & KMOD_CTRL):
gl.TOGGLE_TRANSPARENT ^= 1
my_update_screen(new_img, rect, file)
if event.type == KEYDOWN:
mods = pygame.key.get_mods()
if (event.key == K_t and mods & KMOD_CTRL == 0) and hit_key(event, K_t):
gl.THUMBING = 1
gl.CALC_ZOOM = 0
zoom_percent = gl.CURRENT_ZOOM_PERCENT
real_width = gl.REAL_WIDTH
(new_img, img, refresh_img, file,
rect) = command_thumbs(screen, new_img, file)
if gl.ESCAPED:
gl.CURRENT_ZOOM_PERCENT = zoom_percent
gl.REAL_WIDTH = real_width
gl.ESCAPED = 0
gl.THUMBING = 0
my_update_screen(new_img, rect, file)
if hit_key(event, K_h):
pygame.event.set_allowed(MOUSEMOTION)
gl.HAND_TOOL = 1
drag_hand_cursor()
if gl.REMOTE and not gl.ALREADY_DOWNLOADED:
if hit_key(event, K_a):
save_remote_img(screen, file)
gfx = {'screen': screen, 'rect': rect, 'new_img': new_img, 'img': img, 'refresh_img': refresh_img, 'file': file}
return (gfx, last_rect)
def check_boxes(screen, positions, opt):
# positions[0]=hpos, positions[1]=checked_wpos, positions[2]=unchecked_wpos
# draw checked box:
checked_img = load_img(gl.CHECKED_BOX, False)
checked_rect = checked_img.get_rect()
if opt == "transparent_text":
checked_rect[0] = (positions[1], positions[2])[get_config_val("TRANSPARENT_TEXT")]
elif opt == "main_statusbar":
checked_rect[0] = (positions[2], positions[1])[get_config_val("MAIN_STATUS_BAR")]
elif opt == "four_statusbars":
checked_rect[0] = (positions[2], positions[1])[get_config_val("FOUR_AT_A_TIME_STATUS_BARS")]
elif opt == "exif_statusbar":
checked_rect[0] = (positions[2], positions[1])[get_config_val("ON_THE_FLY_EXIF_STATUS_BAR")]
elif opt == "thumb_statusbars":
checked_rect[0] = (positions[2], positions[1])[get_config_val("THUMBNAIL_STATUS_BARS")]
elif opt == "image_border":
checked_rect[0] = (positions[2], positions[1])[get_config_val("IMAGE_BORDER")]
elif opt == "dirnum_colors":
checked_rect[0] = (positions[2], positions[1])[get_config_val("COLOR_DIRECTORY_NUMBERS")]
elif opt == "lock_zoom":
checked_rect[0] = (positions[2], positions[1])[get_config_val("PERSISTENT_ZOOM")]
elif opt == "wrap":
checked_rect[0] = (positions[2], positions[1])[get_config_val("WRAP")]
elif opt == "wrap_slideshow":
checked_rect[0] = (positions[2], positions[1])[get_config_val("WRAP_SLIDESHOW")]
elif opt == "start_fullscreen":
checked_rect[0] = (positions[2], positions[1])[get_config_val("FULLSCREEN")]
elif opt == "thumb_border":
checked_rect[0] = (positions[2], positions[1])[get_config_val("THUMB_BORDER")]
elif opt == "show_movies":
checked_rect[0] = (positions[2], positions[1])[get_config_val("MOVIES")]
checked_rect[1] = positions[0]
screen.blit(checked_img, checked_rect)
update(checked_rect)
# draw unchecked box:
unchecked_img = load_img(gl.UNCHECKED_BOX, False)
unchecked_rect = unchecked_img.get_rect()
if opt == "transparent_text":
unchecked_rect[0] = (positions[2], positions[1])[get_config_val("TRANSPARENT_TEXT")]
elif opt == "main_statusbar":
unchecked_rect[0] = (positions[1], positions[2])[get_config_val("MAIN_STATUS_BAR")]
elif opt == "four_statusbars":
unchecked_rect[0] = (positions[1], positions[2])[get_config_val("FOUR_AT_A_TIME_STATUS_BARS")]
elif opt == "exif_statusbar":
unchecked_rect[0] = (positions[1], positions[2])[get_config_val("ON_THE_FLY_EXIF_STATUS_BAR")]
elif opt == "thumb_statusbars":
unchecked_rect[0] = (positions[1], positions[2])[get_config_val("THUMBNAIL_STATUS_BARS")]
elif opt == "image_border":
unchecked_rect[0] = (positions[1], positions[2])[get_config_val("IMAGE_BORDER")]
elif opt == "dirnum_colors":
unchecked_rect[0] = (positions[1], positions[2])[get_config_val("COLOR_DIRECTORY_NUMBERS")]
elif opt == "lock_zoom":
unchecked_rect[0] = (positions[1], positions[2])[get_config_val("PERSISTENT_ZOOM")]
elif opt == "wrap":
unchecked_rect[0] = (positions[1], positions[2])[get_config_val("WRAP")]
elif opt == "wrap_slideshow":
unchecked_rect[0] = (positions[1], positions[2])[get_config_val("WRAP_SLIDESHOW")]
elif opt == "start_fullscreen":
unchecked_rect[0] = (positions[1], positions[2])[get_config_val("FULLSCREEN")]
elif opt == "thumb_border":
unchecked_rect[0] = (positions[1], positions[2])[get_config_val("THUMB_BORDER")]
elif opt == "show_movies":
unchecked_rect[0] = (positions[1], positions[2])[get_config_val("MOVIES")]
unchecked_rect[1] = positions[0]
screen.blit(unchecked_img, unchecked_rect)
update(unchecked_rect)
return (checked_rect, unchecked_rect)
from torch.autograd import Variable
from torchvision import transforms
from load_img import load_img, show_img
from run_code import run_style_transfer
style_img = load_img('./picture/style0.png')
style_img = Variable(style_img)
content_img = load_img('./picture/content1.jpg')
content_img = Variable(content_img)
input_img = content_img.clone()
out = run_style_transfer(content_img, style_img, input_img, num_epoches=80)
show_img(out.cpu())
save_pic = transforms.ToPILImage()(out.cpu().squeeze(0))
save_pic.save('./picture/saved_picture.png')
from torchvision import transforms
from run_code import run_style_transfer
from load_img import load_img, show_img
from torch.autograd import Variable
style_img = load_img('./picture/style.png')
style_img = Variable(style_img)
content_img = load_img('./picture/cat.jpg')
content_img = Variable(content_img)
input_img = content_img.clone()
out = run_style_transfer(content_img, style_img, input_img, num_epoches=200)
show_img(out)
save_pic = transforms.ToPILImage()(out.squeeze(0))
save_pic.save('./picture/saved_picture.png')
def extract_features(path_rgb_img,
path_ir_img=None,
patch_size=5,
img_size=(1., 1.),
n_threads=4):
print "Loading images.."
pil_rgb_img = load_img(path_rgb_img)
size_rgb = pil_rgb_img.size
new_size = (0, 0, int(size_rgb[0] * img_size[0]),
int(size_rgb[1] * img_size[1]))
pil_rgb_img = pil_rgb_img.crop(new_size)
pil_rgb_img_grey = pil_rgb_img.convert("L")
if path_ir_img:
pil_ir_img = load_img(path_ir_img)
size_ir = pil_ir_img.size
new_size = (0, 0, int(size_ir[0] * img_size[0]),
int(size_ir[1] * img_size[1]))
pil_ir_img = pil_ir_img.crop(new_size)
pil_ir_img_grey = pil_ir_img.convert("L")
np_ir_img = np.array(pil_ir_img)
np_ir_img_grey = np.array(pil_ir_img_grey)
else:
pil_ir_img = None
pil_ir_img_grey = None
np_ir_img = None
np_ir_img_grey = None
np_rgb_img = np.float32(np.array(pil_rgb_img))
np_rgb_img_grey = np.float32(np.array(pil_rgb_img_grey))
print "shape of np_rgb_img : "
for i in np_rgb_img.shape:
print i
print "Computing gradients.."
dx_rgb_grey = filters.sobel(np_rgb_img_grey, 1)
dy_rgb_grey = filters.sobel(np_rgb_img_grey, 0)
grad_magn = np.sqrt(dx_rgb_grey**2 + dy_rgb_grey**2)
grad_orient = np.arctan2(dy_rgb_grey, dx_rgb_grey)
max_grad_orient = np.max(grad_orient)
grad_orient = grad_orient / max_grad_orient
max_grad_magn = np.max(grad_magn)
grad_magn = grad_magn / max_grad_magn
grad_threshold = 0.4 # arbitrary threshold to detect edges
print "Extracting other features.."
border = int(patch_size / 2)
old_time = int(1000 * time())
# create n_threads processes that will run the run_extract_features function above
processes = []
feat_files_queues = [
] # contains for each thread, the name of the output file with the result
slice_width = int(len(np_rgb_img) / n_threads)
for i in range(0, n_threads - 1):
s, e = i * slice_width, (i + 1) * slice_width
feat_files_queues.append(Queue())
if np_ir_img:
args = (i + 1, np_rgb_img[s:e], np_ir_img[s:e], grad_magn[s:e],
grad_orient[s:e], grad_threshold, border,
feat_files_queues[-1])
else:
args = (i + 1, np_rgb_img[s:e], None, grad_magn[s:e],
grad_orient[s:e], grad_threshold, border,
feat_files_queues[-1])
p = Process(target=run_extract_features, args=args)
processes.append(p)
p.start()
# handle last thread
s = (n_threads - 1) * slice_width
feat_files_queues.append(Queue())
if np_ir_img:
args = (n_threads, np_rgb_img[s:], np_ir_img[s:], grad_magn[s:],
grad_orient[s:], grad_threshold, border, feat_files_queues[-1])
else:
args = (n_threads, np_rgb_img[s:], None, grad_magn[s:],
grad_orient[s:], grad_threshold, border, feat_files_queues[-1])
p = Process(target=run_extract_features, args=args)
processes.append(p)
p.start()
feat_files = []
for q in feat_files_queues:
while q.empty():
sleep(1) # wait 1 second
filename = q.get()
feat_files.append(filename)
time_diff = int(1000 * time()) - old_time
height = min(len(np_rgb_img),
len(np_ir_img)) if np_ir_img else len(np_rgb_img)
#print "final feats has same size than begin: " , len(feats) == height
#print "Total time: %i" % time_diff
# re-create the original shape for the complete set of features
feats = np.vstack(map(lambda x: np.load(x), feat_files))
return feats
def show_thumbs(screen, SPACER, x, i, j, place, marker, font, font_size):
# show thumbnails with correct aspect ratio
if place < len(gl.files):
img_name = gl.files[place]
img = load_img(img_name, 0)
(img_width, img_height) = img.get_size()
splitval = None
if gl.THUMB_VAL.find("x") != -1:
splitval = "x"
elif gl.THUMB_VAL.find("X") != -1:
splitval = "X"
if splitval != None:
(square_width, square_height) = int(gl.THUMB_VAL.split(splitval)[0]), int(gl.THUMB_VAL.split(splitval)[1])
small_img = img
if img_width > img_height:
if (
(not img_width < square_width and not img_height < square_height)
or (img_width > square_width)
or (img_height > square_height)
or (img_width > square_width and img_height > square_height)
):
r = float(img_width) / float(img_height)
new_width = square_width
new_height = int(new_width / r)
scale_val = new_width, new_height
if scale_val[0] > square_width or scale_val[1] > square_height:
scale_val = int(new_width / 1.32), int(new_height / 1.32)
if scale_val[0] > square_width or scale_val[1] > square_height:
if square_width >= 200 or square_height >= 200:
scale_val = int(scale_val[0] / 2), int(scale_val[1] / 2)
small_img = pygame.transform.scale(img, scale_val)
if img_width < img_height:
if (
(not img_width < square_width and not img_height < square_height)
or (img_width > square_width)
or (img_height > square_height)
or (img_width > square_width and img_height > square_height)
):
r = float(img_height) / float(img_width)
new_height = square_height
new_width = int(new_height / r)
scale_val = new_width, new_height
if scale_val[0] > square_width or scale_val[1] > square_height:
scale_val = int(new_width / 2), int(new_height / 2)
else:
scale_val = new_width, new_height
small_img = pygame.transform.scale(img, scale_val)
if img_width == img_height:
if (
(not img_width < square_width and not img_height < square_height)
or (img_width > square_width)
or (img_height > square_height)
or (img_width > square_width and img_height > square_height)
):
r = float(img_width) / float(img_height)
new_height = square_height
new_width = square_width
scale_val = new_width, new_height
small_img = pygame.transform.scale(img, scale_val)
(img_width, img_height) = small_img.get_size()
if (i + square_width) >= screen.get_width():
i = SPACER
j = j + (square_height + SPACER)
if (j + square_height) >= screen.get_height():
i, j = SPACER, SPACER
gl.MAX_THUMBS = marker # figure out how many thumbs fit on a page
set_caption("imgv")
if not gl.MAX_THUMBS_SET:
gl.MAX_THUMBS_SET = gl.MAX_THUMBS
return (x, i, j, place, 1, marker)
# draw individual thumbnail backgrounds:
paint_screen(gl.THUMB_BG_COLOR_VAL, (i, j, square_width, square_height))
if gl.THUMB_BORDER_VAL:
# draw borders:
left_line = line(screen, gl.THUMB_BORDER_COLOR, (i - 1, j - 1), (i - 1, square_height + j))
right_line = line(
screen, gl.THUMB_BORDER_COLOR, (i + square_width, j), (i + square_width, square_height + j)
)
top_line = line(screen, gl.THUMB_BORDER_COLOR, (i, j - 1), ((i + square_width), j - 1))
bottom_line = line(
screen, gl.THUMB_BORDER_COLOR, (i, square_height + j), ((i + square_width), square_height + j)
)
update(left_line), update(top_line), update(right_line), update(bottom_line)
thumb_name = check_truncate(square_width, basename(img_name))
wpos = i + ((square_width / 2) - (font.size(thumb_name)[0] / 2))
small_img_rect = small_img.get_rect()
small_img_rect[0] = i
small_img_rect[1] = j
x.append((small_img_rect, img_name))
screen.blit(small_img, (i, j))
update(small_img_rect)
i = i + (square_width + SPACER)
place = place + 1
marker = marker + 1
if gl.THUMB_STATUS_BARS:
# display thumbnail's filename:
show_message(thumb_name, (wpos, j + square_height - 12), font_size, ("bold"))
if place >= len(gl.files):
return (x, 0, 0, place, 1, marker)
return (x, i, j, place, 0, marker)
from torchvision import transforms
from run_code import run_style_transfer
from load_img import load_img, show_img
from torch.autograd import Variable
style_img = load_img('./picture/style2.jpg')
style_img = Variable(style_img).cpu()
content_img = load_img('./picture/content2.jpg')
content_img = Variable(content_img).cpu()
input_img = content_img.clone()
out = run_style_transfer(content_img, style_img, input_img, num_epoches=200)
show_img(out.cpu())
save_pic = transforms.ToPILImage()(out.cpu().squeeze(0))
save_pic.save('./picture/saved_picture2.jpg')
if __name__ == '__main__':
cfg_from_file(default_cfg)
caffe.set_device(GPU_ID)
caffe.set_mode_gpu()
net = caffe.Net(default_prototxt, default_model, caffe.TEST)
print 'Processing img ...'
image_index = get_image_index(image_set_file)
im_num = len(image_index)
vals = np.empty((im_num, ))
for j in xrange(im_num):
fn = os.path.join(data_dir, image_index[j])
print fn, '\t',
im = load_img(fn)
im -= cfg.PIXEL_MEANS
data = np.zeros((1, 3, im.shape[0], im.shape[1]), dtype=np.float32)
for chn in range(3):
data[0, chn, :, :] = im
blobs_out = net.forward(data=data)
vals[j] = blobs_out['reg_value']
print vals[j]
fn = os.path.join(sys.path[0], 'slice_scores.txt')
with open(fn, 'w') as f:
f.writelines(
[a + '\t' + str(b) + '\r\n' for a, b in zip(image_index, vals)])
print 'Written to', fn
def previous_img(file, old_img, screen):
img = old_img
img = load_img(gl.files[file], screen)
return img
def next_img(file, old_img, screen):
img = old_img
if file < len(gl.files):
img = load_img(gl.files[file], screen)
transitional_fx(screen, img)
return img
def extract_features(path_rgb_img, path_ir_img = None, patch_size=5, img_size=(1.,1.), n_threads=4):
print "Loading images.."
pil_rgb_img = load_img(path_rgb_img)
size_rgb = pil_rgb_img.size
new_size = (0, 0, int(size_rgb[0] * img_size[0]), int(size_rgb[1] * img_size[1]))
pil_rgb_img = pil_rgb_img.crop(new_size)
pil_rgb_img_grey = pil_rgb_img.convert("L")
if path_ir_img:
pil_ir_img = load_img(path_ir_img)
size_ir = pil_ir_img.size
new_size = (0, 0, int(size_ir[0] * img_size[0]), int(size_ir[1] * img_size[1]))
pil_ir_img = pil_ir_img.crop(new_size)
pil_ir_img_grey = pil_ir_img.convert("L")
np_ir_img = np.array(pil_ir_img)
np_ir_img_grey = np.array(pil_ir_img_grey)
else:
pil_ir_img = None
pil_ir_img_grey = None
np_ir_img = None
np_ir_img_grey = None
np_rgb_img = np.float32(np.array(pil_rgb_img))
np_rgb_img_grey = np.float32(np.array(pil_rgb_img_grey))
print "shape of np_rgb_img : "
for i in np_rgb_img.shape:
print i
print "Computing gradients.."
dx_rgb_grey = filters.sobel(np_rgb_img_grey, 1)
dy_rgb_grey = filters.sobel(np_rgb_img_grey, 0)
grad_magn = np.sqrt(dx_rgb_grey**2 + dy_rgb_grey**2)
grad_orient = np.arctan2(dy_rgb_grey, dx_rgb_grey)
max_grad_orient = np.max(grad_orient)
grad_orient = grad_orient / max_grad_orient
max_grad_magn = np.max(grad_magn)
grad_magn = grad_magn / max_grad_magn
grad_threshold = 0.4 # arbitrary threshold to detect edges
print "Extracting other features.."
border = int(patch_size / 2)
old_time = int(1000 * time())
# create n_threads processes that will run the run_extract_features function above
processes = []
feat_files_queues = [] # contains for each thread, the name of the output file with the result
slice_width = int(len(np_rgb_img) / n_threads)
for i in range(0, n_threads-1):
s,e = i * slice_width, (i+1) * slice_width
feat_files_queues.append(Queue())
if np_ir_img:
args = (i+1, np_rgb_img[s:e], np_ir_img[s:e], grad_magn[s:e], grad_orient[s:e], grad_threshold, border,feat_files_queues[-1])
else:
args = (i+1, np_rgb_img[s:e], None, grad_magn[s:e], grad_orient[s:e], grad_threshold, border,feat_files_queues[-1])
p = Process(target=run_extract_features, args=args)
processes.append(p)
p.start()
# handle last thread
s = (n_threads - 1) * slice_width
feat_files_queues.append(Queue())
if np_ir_img:
args = (n_threads, np_rgb_img[s:], np_ir_img[s:], grad_magn[s:], grad_orient[s:], grad_threshold, border, feat_files_queues[-1])
else:
args = (n_threads, np_rgb_img[s:], None, grad_magn[s:], grad_orient[s:], grad_threshold, border, feat_files_queues[-1])
p = Process(target=run_extract_features, args=args)
processes.append(p)
p.start()
feat_files = []
for q in feat_files_queues:
while q.empty():
sleep(1) # wait 1 second
filename = q.get()
feat_files.append(filename)
time_diff = int(1000 * time()) - old_time
height = min(len(np_rgb_img), len(np_ir_img)) if np_ir_img else len(np_rgb_img)
#print "final feats has same size than begin: " , len(feats) == height
#print "Total time: %i" % time_diff
# re-create the original shape for the complete set of features
feats = np.vstack(map(lambda x: np.load(x), feat_files))
return feats
def main():
pygame.time.delay(5) # to make start_timer() work initially
start = start_timer()
num_imgs = len(gl.files)
pygame.init() # needed for Mac OSX?
init_screen()
wait_cursor()
screen = pygame.display.set_mode(gl.DEFAULT_RES, RESIZABLE)
set_caption(gl.TITLE)
if gl.REMOTE == 1:
show_message(screen, "Loading image. Please wait..", 34, 42)
file = 0
if num_imgs < 1:
gl.files = [gl.IMGV_LOGO]
num_imgs = 1
img = load_img(gl.files[file], screen)
else:
img = load_img(gl.files[file], screen)
wait_cursor()
img_width = img.get_width()
img_height = img.get_height()
refresh_img = img
new_img = img
rect = get_center(screen, new_img)
ns = check_timer(start)
my_update_screen(new_img, screen, rect, file, num_imgs, ns)
normal_cursor()
if gl.START_FULLSCREEN:
command_fullscreen(screen, new_img, file, num_imgs, rect)
my_update_screen(new_img, screen, rect, file, num_imgs, ns)
# start with menu open
screen_width = screen.get_width()
screen_height = screen.get_height()
new_img_width = new_img.get_width()
new_img_height = new_img.get_height()
(refresh_img, screen, file, num_imgs, new_img, img,\
new_img_width, new_img_height, rect) = command_main_menu(refresh_img, screen,\
file, len(gl.files), rect, new_img, img, new_img_width, new_img_height, ns)
minus1 = minus2 = 0
# main loop
while 1:
event = pygame.event.poll()
pygame.time.wait(1) # so pygame doesn't use 100% CPU
cursor = pygame.mouse.get_pos()
last_rect = Rect(rect)
screen_width = screen.get_width()
screen_height = screen.get_height()
new_img_width = new_img.get_width()
new_img_height = new_img.get_height()
# drag image code:
if gl.HAND_TOOL:
if left_click(event): # calculate drag coordinates:
if gl.IMG_BORDER:
border_fix(screen) # erase the current border
grab_hand_cursor()
minus1 = cursor[0] - rect[0]
minus2 = cursor[1] - rect[1]
gl.DO_DRAG = 1
if event.type == MOUSEMOTION and gl.DO_DRAG: # move the image when dragged:
grab_hand_cursor()
rect[0] = cursor[0] - minus1
rect[1] = cursor[1] - minus2
screen.fill(gl.IMGV_COLOR, last_rect)
screen.blit(new_img, rect)
update(rect.union(last_rect))
if event.type == MOUSEBUTTONUP: # released mouse button, redisplay status bars:
drag_hand_cursor()
my_update_screen(new_img, screen, rect, file, num_imgs, ns)
gl.DO_DRAG = 0
if event.type == VIDEORESIZE:#
print 'resize imgv.py'#
screen = pygame.display.set_mode(event.dict['size'], RESIZABLE)
rect = get_center(screen, new_img)
my_update_screen(new_img, screen, rect, file, num_imgs, ns)
if event.type == KEYDOWN:
gl.HAND_TOOL = 0
if event.key not in (K_DOWN, K_UP, K_RIGHT, K_LEFT):
normal_cursor() # stop displaying hand tool
(screen, rect, new_img, img, refresh_img, file, num_imgs,\
screen_width, screen_height, new_img_width, new_img_height, last_rect) =\
handle_keyboard(event, screen, rect, new_img, img, refresh_img, file, len(gl.files),\
screen_width, screen_height, new_img_width, new_img_height, last_rect, ns)
if event.type == KEYUP:
stop_auto_repeat()
check_quit(event)
if event.type == MOUSEBUTTONDOWN: # open main menu:
if right_click(event):
gl.HAND_TOOL = 0
(refresh_img, screen, file, num_imgs, new_img, img,\
new_img_width, new_img_height, rect) = command_main_menu(refresh_img, screen,\
file, num_imgs, rect, new_img, img, new_img_width, new_img_height, ns)
if (gl.KEEP_MENU_OPEN == "1" and gl.COUNT_CLICKS == 1) or gl.JUST_RESIZED: # Re-open the purposely closed window that frees up RAM
gl.COUNT_CLICKS = 0
gl.JUST_RESIZED = 0
(refresh_img, screen, file, num_imgs, new_img, img,\
new_img_width, new_img_height, rect) = command_main_menu(refresh_img, screen,\
file, num_imgs, rect, new_img, img, new_img_width, new_img_height, ns)
start_auto_repeat(rect, last_rect, new_img, screen, file, len(gl.files), screen_width, screen_height, event)
clean_screen()
def command_main_menu(refresh_img, screen, file, num_imgs, rect, new_img, img, new_img_width, new_img_height, ns):
menu_items = []
i = 23
cursor = pygame.mouse.get_pos()
screen_width = screen.get_width()
screen_height = screen.get_height()
if screen_height < 600:
font_size = 10
gl.MENU_DIVIDER_AMOUNT = 12
else:
gl.MENU_DIVIDER_AMOUNT = 14
font_size = 11
font = pygame.font.Font(gl.FONT_NAME, font_size)
font.set_bold(1)
if gl.MENU_POS == -1:
gl.MENU_POS = cursor[0]
main_menu_fg(screen, font, i, menu_items)
normal_cursor()
last_rect = Rect(rect)
new_img_width = new_img.get_width()
new_img_height = new_img.get_height()
if gl.REMOTE and not gl.ALREADY_DOWNLOADED:
download_rect = imgv_button(screen, " Downlo(a)d Image ", None, None, "topright")
while 1:
event = pygame.event.poll()
pygame.time.wait(1)
check_quit(event)
cursor2 = pygame.mouse.get_pos()
if event.type == VIDEORESIZE:#
gl.JUST_RESIZED = 1
screen = pygame.display.set_mode(event.dict['size'], RESIZABLE)
rect = get_center(screen, new_img)
my_update_screen(new_img, screen, rect, file, len(gl.files))
return (refresh_img, screen, file, num_imgs, new_img, img, new_img_width, new_img_height, rect)
if gl.REMOTE and not gl.ALREADY_DOWNLOADED:
hover_button(download_rect, cursor2, screen, " Downlo(a)d Image ", None, None, "topright")
if event.type == KEYDOWN:
if event.key in (K_c, K_h, K_UP, K_DOWN, K_RIGHT, K_LEFT):
if event.key != K_c:
pygame.event.set_allowed(MOUSEMOTION)
gl.HAND_TOOL = 1
drag_hand_cursor()
# close the menu
gl.MENU_POS = -1
my_update_screen(new_img, screen, rect, file, len(gl.files))
if event.key == K_c:
normal_cursor()
return (refresh_img, screen, file, num_imgs, new_img, img, new_img_width, new_img_height, rect)
(screen, rect, new_img, img, refresh_img, file, num_imgs,\
screen_width, screen_height, new_img_width, new_img_height, last_rect) =\
handle_keyboard(event, screen, rect, new_img, img, refresh_img, file, len(gl.files),\
screen_width, screen_height, new_img_width, new_img_height, last_rect, ns)
break
hover_cursor(cursor2, [x[0] for x in menu_items])
if left_click(event):
if gl.REMOTE and not gl.ALREADY_DOWNLOADED:
if download_rect.collidepoint(cursor2):
wait_cursor()
save_remote_img(screen, file)
break
for it in menu_items:
if it[0].collidepoint(cursor2):
if it[1] == " Next Image ":
(new_img, img, refresh_img, file, rect) = command_next_img(new_img, screen, file, len(gl.files), rect)
elif it[1] == " Previous Image ":
(new_img, img, refresh_img, file, rect) = command_prev_img(new_img, screen, file, len(gl.files), rect)
elif it[1] == " Directory Browser ":
gl.USING_SCROLL_MENU = 1
# save current things in case the user ESCAPES out of show_dirs()
gl.LAST_DIR = getcwd()
last_files = gl.files
(last_new_img, last_img, last_refresh_img, last_num_imgs, last_file, last_rect) =\
(new_img, img, refresh_img, num_imgs, file, rect)
(new_img, img, refresh_img, num_imgs, file, rect) = command_show_dirs(new_img, img, screen, rect,\
file, num_imgs)
# user ESCAPED from show_dirs, reset last values
if gl.ESCAPED:
(new_img, img, refresh_img, num_imgs, file, rect) =\
(last_new_img, last_img, last_refresh_img, last_num_imgs, last_file, last_rect)
chdir(gl.LAST_DIR)
gl.files = last_files
gl.USING_SCROLL_MENU = 0
my_update_screen(new_img, screen, rect, file, num_imgs)
else:
gl.REFRESH_IMG_COUNT = 0
gl.ESCAPED = 0
gl.USING_SCROLL_MENU = 0
elif it[1] == " Image Browser ":
(new_img, img, refresh_img, file, rect) = command_img_names(screen, new_img, img, file,\
num_imgs, rect)
elif it[1] == " Thumbnails ":
gl.THUMBING = 1
gl.CALC_ZOOM = 0
zoom_percent = gl.CURRENT_ZOOM_PERCENT
real_width = gl.REAL_WIDTH
(new_img, img, refresh_img, file, rect) = command_thumbs(screen, new_img, file, ns)
if gl.ESCAPED:
gl.CURRENT_ZOOM_PERCENT = zoom_percent
gl.REAL_WIDTH = real_width
gl.ESCAPED = 0
gl.THUMBING = 0
my_update_screen(new_img, screen, rect, file, num_imgs)
elif it[1] == " Image Properties ":
transparency = 0
if not gl.TOGGLE_TRANSPARENT:
gl.TOGGLE_TRANSPARENT = 1
transparency = 1
command_verbose_info(screen, new_img, rect, file, num_imgs)
if transparency:
gl.TOGGLE_TRANSPARENT = 0
my_update_screen(new_img, screen, rect, file, num_imgs)
elif it[1] == " Zoom Out ":
if int(gl.N_MILLISECONDS) < gl.MAX_ZOOM_MAX_MS and gl.CURRENT_ZOOM_PERCENT< gl.ZOOM_PERCENT_MAX:
try:
(new_img, img, rect) = command_zoom_out(new_img, new_img_width, new_img_height, img, screen, file, num_imgs, rect, "normal")
except:
print 'Out of memory.'
else:
print "Can't zoom out. Out of memory. Resetting the image."
gl.SKIP_FIT = 1
gl.ZOOM_EXP = 0
start = start_timer()
wait_cursor()
new_img = load_img(gl.files[file], screen)
img = refresh_img = new_img
rect = get_center(screen, new_img)
ns = check_timer(start)
my_update_screen(new_img, screen, rect, file, num_imgs, ns)
normal_cursor()
gl.N_MILLISECONDS = "0"
elif it[1] == " Zoom In ":
if int(gl.N_MILLISECONDS) < gl.MAX_ZOOM_MAX_MS and gl.CURRENT_ZOOM_PERCENT < gl.ZOOM_PERCENT_MAX:
try: # triple zoom crash protection
(new_img, img, rect) = command_zoom_in(new_img, new_img_width, new_img_height, img, screen, gl.files, file, num_imgs, rect, "normal")
except:
print 'Zoom max reached.'
else:
print 'Zoom max reached.'
elif it[1] == " Fit to Window ":
gl.RESET_FIT = 0
gl.SCALE_UP = 1
if gl.FIT_IMAGE_VAL:
gl.RESET_FIT = 0
else:
gl.RESET_FIT = 1
gl.FIT_IMAGE_VAL = 1
start = start_timer()
wait_cursor()
new_img = load_img(gl.files[file], screen)
img = refresh_img = new_img
rect = get_center(screen, new_img)
ns = check_timer(start)
my_update_screen(new_img, screen, rect, file, num_imgs, ns)
if gl.RESET_FIT == 1:
gl.FIT_IMAGE_VAL = 0
normal_cursor()
elif it[1] == " Lock Zoom ":
gl.PERSISTENT_ZOOM_VAL ^= 1
if not gl.PERSISTENT_ZOOM_VAL:
gl.ZOOM_EXP = 0
my_update_screen(new_img, screen, rect, file, num_imgs, ns)
elif it[1] == " Actual Size ":
gl.SKIP_FIT = 1
gl.ZOOM_EXP = 0
start = start_timer()
wait_cursor()
new_img = load_img(gl.files[file], screen)
img = refresh_img = new_img
rect = get_center(screen, new_img)
ns = check_timer(start)
my_update_screen(new_img, screen, rect, file, num_imgs, ns)
normal_cursor()
elif it[1] == " Close Image ":
(new_img, img, refresh_img, file, num_imgs, rect) = command_remove_img(new_img, screen, file, rect)
elif it[1] == " Rotate Right ":
if int(gl.N_MILLISECONDS) < gl.MAX_ZOOM_MAX_MS and gl.CURRENT_ZOOM_PERCENT < gl.ZOOM_PERCENT_MAX:
gl.CALC_ZOOM = 0
(new_img, img, rect) = command_rotate_right(new_img, screen, file, num_imgs, rect)
else:
print "Can't rotate. Out of memory."
elif it[1] == " Rotate Left ":
if int(gl.N_MILLISECONDS) < gl.MAX_ZOOM_MAX_MS and gl.CURRENT_ZOOM_PERCENT < gl.ZOOM_PERCENT_MAX:
gl.CALC_ZOOM = 0
(new_img, img, rect) = command_rotate_left(new_img, screen, file, num_imgs, rect)
else:
print "Can't rotate. Out of memory."
elif it[1] == " Four at a Time ":
gl.CALC_ZOOM = 0
zoom_percent = gl.CURRENT_ZOOM_PERCENT
real_width = gl.REAL_WIDTH
(file, new_img, img, refresh_img, rect) = command_four(screen, file, new_img, ns)
if gl.ESCAPED:
gl.CURRENT_ZOOM_PERCENT = zoom_percent
gl.REAL_WIDTH = real_width
gl.ESCAPED = 0
my_update_screen(new_img, screen, rect, file, num_imgs)
normal_cursor()
# elif it[1] == " Resize Options ":##
# gl.USING_SCROLL_MENU = 1
# gl.CALC_ZOOM = 0
# zoom_percent = gl.CURRENT_ZOOM_PERCENT
# real_width = gl.REAL_WIDTH
# rect = command_show_res_modes(screen, new_img, file, num_imgs, rect)
# gl.CURRENT_ZOOM_PERCENT = zoom_percent
# gl.REAL_WIDTH = real_width
# gl.USING_SCROLL_MENU = 0
elif it[1] == " Refresh ":
(new_img, img, rect, file) = command_refresh(refresh_img, screen, gl.files, file, num_imgs)
elif it[1] == " First Image ":
(new_img, img, refresh_img, file, rect) = command_first_img(new_img, screen, file, len(gl.files), rect)
elif it[1] == " Last Image ":
(new_img, img, refresh_img, file, rect) = command_last_img(new_img, screen, file, len(gl.files), rect)
elif it[1] == " Shuffle ":
(new_img, img, refresh_img, rect) = command_shuffle(new_img, img, screen, rect, file, num_imgs)
elif it[1] == " Unshuffle ":
(new_img, img, refresh_img, rect, file) = command_unshuffle(new_img, img, screen, rect, file, num_imgs)
elif it[1] == " Flip Horizontal ":
(new_img, img, rect) = command_horiz(new_img, screen, file, num_imgs, rect)
elif it[1] == " Flip Vertical ":
(new_img, img, rect) = command_vert(new_img, screen, file, num_imgs, rect)
elif it[1] == " Slideshow ":
(new_img, img, refresh_img, file, rect) = my_slideshow(new_img, img, screen, file, num_imgs, rect)
my_update_screen(new_img, screen, rect, file, len(gl.files))
elif it[1] == " Playlists ":
(new_img, new_img, new_img, file, rect, num_imgs) = command_play_list_options(screen, file)
gl.SORT_HIT = 0
elif it[1] == " Add to Playlist ":
command_add_to_play_list(screen, gl.files[file])
gl.SORT_HIT = 0
my_update_screen(new_img, screen, rect, file, len(gl.files))
elif it[1] == " Edit ":
(screen, before_winsize, not_accepted) = adjust_screen(screen)
gl.USING_SCROLL_MENU = 1
(new_img, img, refresh_img, file, num_imgs, rect) = command_edit_menu(screen, file, new_img, num_imgs, rect)
screen = restore_screen(screen, before_winsize, not_accepted, new_img, file, num_imgs, rect)
my_update_screen(new_img, screen, rect, file, num_imgs)
gl.USING_SCROLL_MENU = 0
elif it[1] == " Hide Image ":
command_hide(screen, new_img, rect, file, num_imgs)
elif it[1] == " Extract from Web ":
(screen, before_winsize, not_accepted) = adjust_screen(screen)
(new_img, num_imgs) = open_url(screen, img)
gl.URL_ERROR = False
file = 0
img = refresh_img = new_img
screen = restore_screen(screen, before_winsize, not_accepted, new_img, file, num_imgs, rect)
rect = get_center(screen, new_img)
my_update_screen(new_img, screen, rect, file, len(gl.files))
normal_cursor()
elif it[1] == " Help ":
gl.CALC_ZOOM = 0
zoom_percent = gl.CURRENT_ZOOM_PERCENT
real_width = gl.REAL_WIDTH
command_help(screen, new_img, file, rect, num_imgs)
if gl.ESCAPED:
gl.CURRENT_ZOOM_PERCENT = zoom_percent
gl.REAL_WIDTH = real_width
gl.ESCAPED = 0
elif it[1] == " Close Menu " or it[1] == " Hand Tool ":
if it[1] == " Hand Tool ":
pygame.event.set_allowed(MOUSEMOTION)
gl.HAND_TOOL = 1
drag_hand_cursor()
gl.MENU_POS = -1
my_update_screen(new_img, screen, rect, file, len(gl.files))
normal_cursor()
return (refresh_img, screen, file, num_imgs, new_img, img, new_img_width, new_img_height, rect)
elif it[1] == " Exit ":
clean_screen()
raise SystemExit
break
if event.type == KEYDOWN and event.key not in (K_LALT, K_RALT, K_LCTRL, K_RCTRL, K_TAB):
return (refresh_img, screen, file, num_imgs, new_img, img, new_img_width, new_img_height, rect)
if middle_click(event):
"close the menu upon middle click"
gl.MENU_POS = -1
my_update_screen(new_img, screen, rect, file, len(gl.files))
normal_cursor()
return (refresh_img, screen, file, num_imgs, new_img, img, new_img_width, new_img_height, rect)
if right_click(event):
wait_cursor()
gl.MENU_POS = -1
my_update_screen(new_img, screen, rect, file, len(gl.files))
(refresh_img, screen, file, num_imgs, new_img, img, new_img_width, new_img_height, rect) =\
command_main_menu(refresh_img, screen, file, num_imgs, rect, new_img, img, new_img_width, new_img_height, ns)
return (refresh_img, screen, file, num_imgs, new_img, img, new_img_width, new_img_height, rect)
if event.type == MOUSEBUTTONDOWN: # this needs to be down here to work
if event.dict['button'] in (4, 5): # scroll wheel activated
# allow for mouse dragging:
pygame.event.set_allowed(MOUSEMOTION)
gl.HAND_TOOL = 1
drag_hand_cursor()
# close menu:
gl.MENU_POS = -1
my_update_screen(new_img, screen, rect, file, len(gl.files))
return (refresh_img, screen, file, num_imgs, new_img, img, new_img_width, new_img_height, rect)
if gl.KEEP_MENU_OPEN == "1":
# this code purposely closes the main menu by breaking the recursion to free up RAM memory
gl.COUNT_CLICKS += 1
if gl.COUNT_CLICKS == 1: # free up ram every click
return (refresh_img, screen, file, num_imgs, new_img, img, new_img_width, new_img_height, rect)
(refresh_img, screen, file, num_imgs, new_img, img, new_img_width, new_img_height, rect) =\
command_main_menu(refresh_img, screen, file, num_imgs, rect, new_img, img, new_img_width, new_img_height, ns)
normal_cursor()
return (refresh_img, screen, file, num_imgs, new_img, img, new_img_width, new_img_height, rect)
if __name__ == '__main__':
cfg_from_file(default_cfg)
caffe.set_device(GPU_ID)
caffe.set_mode_gpu()
net = caffe.Net(default_prototxt, default_model, caffe.TEST)
print 'Processing img ...'
image_index = get_image_index(image_set_file)
im_num = len(image_index)
vals = np.empty((im_num,))
for j in xrange(im_num):
fn = os.path.join(data_dir, image_index[j])
print fn, '\t',
im = load_img(fn)
im -= cfg.PIXEL_MEANS
data = np.zeros((1, 3, im.shape[0], im.shape[1]), dtype=np.float32)
for chn in range(3):
data[0, chn, :, :] = im
blobs_out = net.forward(data=data)
vals[j] = blobs_out['reg_value']
print vals[j]
fn = os.path.join(sys.path[0], 'slice_scores.txt')
with open(fn,'w') as f:
f.writelines([a + '\t' + str(b) + '\r\n' for a,b in zip(image_index, vals)])
print 'Written to', fn
def thumbs_engine(screen, new_img, file):
screen_pause = 0
SPACER = 5
x = []
place = file # start thumbing from current image position
marker = 0
(i, j) = (SPACER, SPACER)
(esc_rect, close_font) = close_button(screen)
font_size = 9
font = pygame.font.Font(gl.FONT_NAME, font_size)
pygame.event.set_blocked(MOUSEMOTION)
while 1:
event = pygame.event.poll()
pygame.time.wait(1)
check_quit(event)
cursor = pygame.mouse.get_pos()
hover_cursor(cursor, (esc_rect,))
gl.PAUSED = 0 # critical
if hit_key(event, K_ESCAPE):
gl.ESCAPED = 1
return (new_img, new_img, new_img, file)
if left_click(event):
if esc_rect.collidepoint(cursor):
gl.ESCAPED = 1
break
if hit_key(event, K_t) or hit_key(event, K_p) or hit_key(event, K_PAUSE):
# pause
set_caption("Thumbnails [Paused]")
try:
if place % gl.MAX_THUMBS_SET != 0:
# only pause if it's not the last thumbnail on the page
gl.PAUSED = 1
screen_pause = 1
except:
gl.PAUSED = 1
screen_pause = 1
if screen_pause == 1:
normal_cursor()
while 1:
event = pygame.event.poll()
pygame.time.wait(1)
cursor = pygame.mouse.get_pos()
(esc_rect, close_font) = close_button(screen)
hover_fx(screen, x, cursor, marker)
hover_cursor(cursor, [esc_rect] + [y[0] for y in x])
if left_click(event):
if esc_rect.collidepoint(cursor):
gl.ESCAPED = 1
return (new_img, new_img, new_img, file)
for item in x: # load clicked image:
if item[0].collidepoint(cursor):
wait_cursor()
new_img = load_img(item[1])
file = gl.files.index(item[1])
return (new_img, new_img, new_img, file)
check_quit(event)
if (
hit_key(event, K_SPACE)
or hit_key(event, K_t)
or hit_key(event, K_n)
or hit_key(event, K_p)
or hit_key(event, K_PAUSE)
or right_click(event)
):
if not place >= len(gl.files):
if not gl.PAUSED: # go to next thumb page:
paint_screen(gl.IMGV_COLOR)
close_button(screen)
set_caption("Thumbnails [Paused]")
x = []
screen_pause = 0
marker = 0
break
# unpause:
gl.PAUSED = 0
screen_pause = 0
break
if hit_key(event, K_BACKSPACE) or hit_key(event, K_b) or middle_click(event):
# go back to previous thumb page, even if paused:
if (place - marker) > 0:
i = j = SPACER
if gl.PAUSED:
gl.PAUSED = 0
paint_screen(gl.IMGV_COLOR)
close_button(screen)
screen_pause = 0
place = place - (marker + gl.MAX_THUMBS)
marker = 0
x = []
break
if hit_key(event, K_ESCAPE):
gl.ESCAPED = 1
return (new_img, new_img, new_img, file)
else:
set_caption("Loading Thumbnails [%d] - imgv" % marker)
(x, i, j, place, screen_pause, marker) = show_thumbs(
screen, SPACER, x, i, j, place, marker, font, font_size
)
pygame.time.delay(5)
return (new_img, new_img, new_img, file)
def command_show_res_modes(screen, new_img, file, num_imgs, rect):
paint_screen(screen, gl.BLACK)
set_caption("Resize Options - imgv")
menu_items = []
(esc_rect, font) = close_button(screen)
res_font = pygame.font.Font(gl.FONT_NAME, 18)
res_font.set_bold(1)
show_message(screen, "Choose a preset or custom window size for imgv", "top", 12, ("underline", "bold"))
show_message(screen, "Use current window size as fullscreen resolution?", (170, 192), 10)
show_message(screen, "No Yes", (430, 182), 10)
show_message(screen, "Option: _", "bottom", 12)
(menu_items, men_ops) = show_res_modes(screen, menu_items, res_font)
pygame.event.set_blocked(MOUSEMOTION)
while 1:
event = pygame.event.poll()
pygame.time.wait(35) # don't use 100% CPU
cursor = pygame.mouse.get_pos()
hover_fx(screen, menu_items, cursor, res_font)
if gl.NOT_HOVERED:
show_message(screen, "%sOption: _%s" % (" " * 100, " " * 100), "bottom", 12)
blank_fx(screen, 0)
check_quit(event)
if event.type == VIDEORESIZE:
screen = pygame.display.set_mode(event.dict['size'], RESIZABLE)
rect = get_center(screen, new_img)
command_show_res_modes(screen, new_img, file, num_imgs, rect)
break
# draw checked box:
checked_img = load_img(gl.CHECKED_BOX, screen, False)
checked_img_rect = checked_img.get_rect()
if gl.FULLSCREEN_SPECIAL == 0:
checked_img_rect[0] = 432
else:
checked_img_rect[0] = 455
checked_img_rect[1] = 195
screen.blit(checked_img, checked_img_rect)
update(checked_img_rect)
# draw unchecked box:
unchecked_img = load_img(gl.UNCHECKED_BOX, screen, False)
unchecked_img_rect = unchecked_img.get_rect()
if gl.FULLSCREEN_SPECIAL == 0:
unchecked_img_rect[0] = 455
else:
unchecked_img_rect[0] = 432
unchecked_img_rect[1] = 195
screen.blit(unchecked_img, unchecked_img_rect)
update(unchecked_img_rect)
hover_cursor(cursor, [esc_rect, checked_img_rect, unchecked_img_rect] + [x[0] for x in menu_items])
if hit_key(event, K_ESCAPE):
update_res_screen(screen, file, new_img)
return rect
if event.type == KEYDOWN and event.key in (K_F2, K_F3, K_F4, K_F5, K_F6, K_c):
if hit_key(event, K_F2):
rect = command_640x480(new_img, file, num_imgs, rect)
if hit_key(event, K_F3):
rect = command_800x600(new_img, file, num_imgs, rect)
if hit_key(event, K_F4):
rect = command_1024x768(new_img, file, num_imgs, rect)
if hit_key(event, K_F5):
rect = command_1280x1024(new_img, file, num_imgs, rect)
if hit_key(event, K_F6):
screen = command_fullscreen(screen, new_img, file, num_imgs, rect)
rect = get_center(screen, new_img)
my_update_screen(new_img, screen, rect, file, num_imgs)
if hit_key(event, K_c):
rect = do_custom(screen, new_img, file, num_imgs, rect)
return rect
if left_click(event):
if esc_rect.collidepoint(cursor):
gl.ESCAPED = 1
update_res_screen(screen, file, new_img)
return rect
if unchecked_img_rect.collidepoint(cursor):
gl.FULLSCREEN_SPECIAL ^= 1 # toggle
for it in menu_items:
if it[0].collidepoint(cursor) and it[1] in men_ops:
if it[1] == "F2) 640x480":
rect = command_640x480(new_img, file, num_imgs, rect)
elif it[1] == "F3) 800x600":
rect = command_800x600(new_img, file, num_imgs, rect)
elif it[1] == "F4) 1024x768":
rect = command_1024x768(new_img, file, num_imgs, rect)
elif it[1] == "F5) 1280x1024":
rect = command_1280x1024(new_img, file, num_imgs, rect)
elif it[1] == "F6) Fullscreen":
screen = command_fullscreen(screen, new_img, file, num_imgs, rect)
rect = get_center(screen, new_img)
my_update_screen(new_img, screen, rect, file, num_imgs)
elif it[1] == "C) Custom":
rect = do_custom(screen, new_img, file, num_imgs, rect)
return rect
gl.NOT_HOVERED = 1
return rect
from torchvision import transforms
from run_code import run_style_transfer
from load_img import load_img, show_img
from torch.autograd import Variable
style_img = load_img('./picture/star.jpg')
# style_img = Variable(style_img).cpu()
style_img = Variable(style_img).cuda()
content_img = load_img('./picture/tower.jpg')
# content_img = Variable(content_img).cpu()
content_img = Variable(content_img).cuda()
input_img = content_img.clone()
out = run_style_transfer(content_img, style_img, input_img, num_epoches=200)
print("style_transfer_img is ...")
show_img(out.cpu())
save_pic = transforms.ToPILImage()(out.cpu().squeeze(0))
save_pic.save('./picture/star_tower.jpg')
from torchvision import transforms
from run_code import run_style_transfer
from load_img import load_img, show_img
from torch.autograd import Variable
style_img = load_img('./picture/style.jpg')
style_img = Variable(style_img).cuda()
content_img = load_img('D:\image_face/18.jpg')
content_img = Variable(content_img).cuda()
input_img = content_img.clone()
out = run_style_transfer(content_img, style_img, input_img, num_epoches=200)
show_img(out.cpu())
save_pic = transforms.ToPILImage()(out.cpu().squeeze(0))
save_pic.save('./picture/saved_picture.png')
def four(screen, file, new_img, ns):
paint_screen(screen, gl.IMGV_COLOR) # so transparent status bars don't mess up on VIDEOEXPOSE repaints
old_file = file
(img_one_rect, img_two_rect, img_three_rect, img_four_rect) = (0, 0, 0, 0)
(img_one_name, img_two_name, img_three_name, img_four_name) = (0, 0, 0, 0)
(show_img_one, show_img_two, show_img_three, show_img_four) = (0, 0, 0, 0)
rect = show_message(screen, "", "bottom", 9, ("bold")) # needed to not paint on esc_rect first time
(file, img_one_rect, img_one_name, img_one_file) = square_one(screen, file)
(file, img_two_rect, img_two_name, img_two_file) = square_two(screen, file)
(file, img_three_rect, img_three_name, img_three_file) = square_three(screen, file)
(file, img_four_rect, img_four_name, img_four_file) = square_four(screen, file)
(esc_rect, close_font) = close_button(screen)
start = ns
while 1:
flag = 0
event = pygame.event.poll()
pygame.time.wait(1)
cursor = pygame.mouse.get_pos()
if event.type == VIDEORESIZE:
pygame.event.set_blocked(VIDEOEXPOSE)
screen = pygame.display.set_mode(event.dict['size'], RESIZABLE)
file = file - 4
pygame.event.set_allowed(VIDEOEXPOSE)
(file, new_img, start) = four(screen, file, new_img, ns)
flag = 1
break
if hit_key(event, K_ESCAPE):
gl.ESCAPED = 1
file = old_file
break
check_quit(event)
if hit_key(event, K_SPACE) or hit_key(event, K_n) or hit_key(event, K_4) or right_click(event): # show next 4 images
paint_screen(screen, gl.IMGV_COLOR)
flag = 1
if hit_key(event, K_BACKSPACE) or hit_key(event, K_b) or middle_click(event): # show previous 4 images
paint_screen(screen, gl.IMGV_COLOR)
file = file - 8
flag = 1
if flag == 1:
(file, img_one_rect, img_one_name, img_one_file) = square_one(screen, file)
if flag == 1:
(file, img_two_rect, img_two_name, img_two_file) = square_two(screen, file)
if flag == 1:
(file, img_three_rect, img_three_name, img_three_file) = square_three(screen,\
file)
if flag == 1:
(file, img_four_rect, img_four_name, img_four_file) = square_four(screen, file)
(show_img_one, show_img_two, show_img_three, show_img_four, rect) = hover_square(\
screen, show_img_one, show_img_two, show_img_three, show_img_four, img_one_rect,\
img_two_rect, img_three_rect, img_four_rect, img_one_name, img_two_name, img_three_name,\
img_four_name, img_one_file, img_two_file, img_three_file, img_four_file, rect, event)
hover_fx(screen, img_one_name, img_two_name, img_three_name, img_four_name, img_one_rect, img_two_rect, img_three_rect, img_four_rect, cursor)
if show_img_one == None:
file = old_file
break
if hit_key(event, K_w):
if len(gl.files) <= 1: # nothin to slideshow
file = old_file
break # kick 'em out
(file, img_one_file, img_two_file, img_three_file, img_four_file) =\
my_fourslideshow(screen, new_img, rect, gl.files[file], file - 4,\
len(gl.files), img_one_file, img_two_file, img_three_file, img_four_file, ns)
paint_screen(screen, gl.IMGV_COLOR)
(file, new_img, start) = four(screen, file - 4, new_img, ns)
flag = 1
break
if left_click(event):
start = start_timer()
if img_one_rect.collidepoint(cursor):
wait_cursor()
new_img = load_img(gl.files[img_one_file], screen)
return (img_one_file, new_img, start)
if img_two_rect.collidepoint(cursor):
wait_cursor()
new_img = load_img(gl.files[img_two_file], screen)
return (img_two_file, new_img, start)
if img_three_rect.collidepoint(cursor):
wait_cursor()
new_img = load_img(gl.files[img_three_file], screen)
return (img_three_file, new_img, start)
if img_four_rect.collidepoint(cursor):
wait_cursor()
new_img = load_img(gl.files[img_four_file], screen)
return (img_four_file, new_img, start)
if esc_rect.collidepoint(cursor):
file = old_file
gl.ESCAPED = 1
break
if event.type == VIDEOEXPOSE:
# if event.type == VIDEOEXPOSE and not pygame.mouse.get_focused():#
# repaint the screen in case other windows painted over it:
file = file - 4
(file, new_img, start) = four(screen, file, new_img, ns)
flag = 1
break
return (file, new_img, start)
def _get_minibatch(self, volume_ids):
ims = []
for i in range(self.group_size):
while True:
try_again = False
volume_id = volume_ids[i]
nIm = len(self.data_list[volume_id])
k = np.random.randint(np.floor(nIm / self.slice_num)) + 1
s = 1 / (1 + np.exp((np.random.rand(1) - .5) * 2 * 5)
) # give more chance to top and bottom slices because
# the middle slices naturally have larger probability of being selected
start = int(s * (nIm - k * (self.slice_num - 1)))
# start = np.random.choice(nIm - d*(self.slice_num-1)) # original
img_ids = [start + j * k for j in range(self.slice_num)]
# count the frequency of selection of each part of the volume
r = np.floor(np.array(img_ids, dtype=np.float) / nIm * 50)
self._sel_hist[r.astype(np.int)] += 1
ims1 = []
for img_id in img_ids:
# print volume_id, img_id, len(self.fd_list), len(self.data_list[volume_id])
fn = os.path.join(self.fd_list[volume_id],
self.data_list[volume_id][img_id])
if os.path.getsize(
fn
) < cfg.TRAIN.MIN_IM_SIZE_KB: # very small size indicates the image contains very little contents
try_again = True
break
im = load_img(fn)
# print im.shape
if im is None:
try_again = True
break
if cfg.TRAIN.CROP_RANDOM_PATCH:
# randomly crop a 2D patch
H, W = im.shape
area = im.sum()
while True:
r = np.random.rand() * .5 + .5
h = np.random.randint(H / 2, H + 1)
w = min(W, int(np.ceil(float(H * W) * r / h)))
y = np.random.randint(H - h + 1)
x = np.random.randint(W - w + 1)
# print mask[y:y+h, x:x+w].sum(), area
if im[y:y + h, x:x + w].sum() < area / 3:
continue # prevent selecting large black area
im = im[y:y + h, x:x + w]
break
im -= self.avg_img
ims1.append(im)
if try_again:
print '~', fn
continue
else:
ims += ims1
break
if DEBUG: print img_ids, nIm
# print self._sel_hist, self._sel_hist/self._sel_hist.sum()
return ims
