def set_style(content_image_name, style_image_name):
content_image = utility.load_image(content_image_name)
style_image = utility.load_image(style_image_name, style_image=True)
style_image = tf.nn.avg_pool(style_image,
ksize=[3, 3],
strides=[1, 1],
padding='SAME')
# Load TF-Hub module.
hub_handle = 'https://tfhub.dev/google/magenta/arbitrary-image-stylization-v1-256/2'
hub_module = hub.load(hub_handle)
outputs = hub_module(tf.constant(content_image), tf.constant(style_image))
return outputs[0]
def load(self):
filename, basename, reference = load_image(self)
if filename is None:
return
if reference.shape != self.evidence.shape:
QMessageBox.critical(
self, self.tr("Error"),
self.tr("Evidence and reference must have the same size!"))
return
self.reference = reference
self.reference_viewer.set_title(self.tr(f"Reference: {basename}"))
self.difference = norm_mat(cv.absdiff(self.evidence, self.reference))
self.comp_label.setEnabled(True)
self.normal_radio.setEnabled(True)
self.difference_radio.setEnabled(True)
self.ssim_radio.setEnabled(False)
self.butter_radio.setEnabled(False)
self.gray_check.setEnabled(True)
self.equalize_check.setEnabled(True)
self.metric_button.setEnabled(True)
for i in range(self.table_widget.rowCount()):
self.table_widget.setItem(i, 1, QTableWidgetItem())
self.normal_radio.setChecked(True)
self.table_widget.setEnabled(False)
self.change()
def __init__(self):
super().__init__()
self.image = load_image("Enemy.png")
self.surf = pygame.Surface((99, 126))
self.rect = self.surf.get_rect(center=(SCREEN_WIDTH / 2,
SCREEN_HEIGHT * 0.2))
self.velocity = pygame.math.Vector2(GOALKEEPER_SPEED, 0)
def __init__(self):
super().__init__()
self.image = load_image("Ball.png")
self.surf = pygame.Surface((50, 50))
self.rect = self.surf.get_rect(center=(SCREEN_WIDTH / 2,
SCREEN_HEIGHT / 2))
self.velocity = pygame.math.Vector2(0, 0)
def __init__(self):
self.points = []
self.frame = pyglet.sprite.Sprite(load_image('frame.png'),
-500, -500, batch=mainbatches[2]) # noqa
self.modules = {
'characters': [],
}
def DrawLevel():
margin = 0
h = 20
v = (20+BULLET_HEIGHT)*2
Wall(-margin, -margin, FIELD_WIDTH+2*margin, margin+v)
Wall(-margin, FIELD_HEIGHT-v, FIELD_WIDTH+2*margin, v+margin)
Wall(-margin, -margin, margin+h, FIELD_HEIGHT+2*margin)
Wall(FIELD_WIDTH-h, -margin, h+margin, FIELD_HEIGHT+2*margin)
tile = load_image('ground.png')
tile_width, tile_height = tile.get_size()
for x in xrange(1+SCREEN_WIDTH/tile_width):
for y in xrange(1+SCREEN_HEIGHT/tile_height):
BACKGROUND.blit(tile, (x*tile_width, y*tile_height))
def set_game_obj_images():
player_image = utility.load_image("player1.gif")
Player.images = [player_image, pygame.transform.flip(player_image, 1, 0)]
explosion_image = utility.load_image("explosion1.gif")
Explosion.images = [explosion_image,
pygame.transform.flip(explosion_image, 1, 1)]
Alien.images = utility.load_images(
"alien1.gif", "alien2.gif", "alien3.gif")
Bomb.images = [utility.load_image("bomb.gif")]
Shot.images = [utility.load_image("shot.gif")]
icon = pygame.transform.scale(Alien.images[0], (32, 32))
pygame.desplay.set_icon(icon)
pygame.desplay.set_caption("boi parti")
def load_mask(self):
filename, basename, mask = load_image(self)
if filename is None:
return
if self.image.shape[:-1] != mask.shape[:-1]:
QMessageBox.critical(
self, self.tr('Error'),
self.tr('Both image and mask must have the same size!'))
return
_, self.mask = cv.threshold(cv.cvtColor(mask, cv.COLOR_BGR2GRAY), 0, 1,
cv.THRESH_BINARY)
self.onoff_button.setEnabled(True)
self.onoff_button.setChecked(True)
self.mask_button.setText('"{}"'.format(splitext(basename)[0]))
self.mask_button.setToolTip(self.tr('Current detection mask image'))
def load(self):
filename, basename, image = load_image(self)
if filename is None:
return
if image.shape != self.evidence.shape:
QMessageBox.critical(
self, self.tr('Error'),
self.tr('Evidence and reference must have the same size!'))
return
self.file_label.setText(basename)
self.reference = image
self.difference = normalize_mat(
cv.absdiff(self.evidence, self.reference))
self.equalized = cv.merge(
[cv.equalizeHist(c) for c in cv.split(self.difference)])
x = cv.cvtColor(self.evidence, cv.COLOR_BGR2GRAY).astype(np.float32)
y = cv.cvtColor(self.reference, cv.COLOR_BGR2GRAY).astype(np.float32)
mse = self.mse(x, y)
covar = self.covar(x, y)
psnr = self.psnr(mse)
ssim, self.indexmap = self.ssim(x, y)
corr = self.corr(x, y)
self.table_widget.setItem(0, 1, QTableWidgetItem('{:.4f}'.format(mse)))
self.table_widget.setItem(1, 1,
QTableWidgetItem('{:.4f}'.format(covar)))
if psnr > 0:
self.table_widget.setItem(
2, 1, QTableWidgetItem('{:.2f} dB'.format(psnr)))
else:
self.table_widget.setItem(
2, 1, QTableWidgetItem('+' + u'\u221e' + ' dB'))
self.table_widget.setItem(3, 1,
QTableWidgetItem('{:.4f}'.format(ssim)))
self.table_widget.setItem(4, 1,
QTableWidgetItem('{:.4f}'.format(corr)))
self.table_widget.setEnabled(True)
self.comp_label.setEnabled(True)
self.normal_radio.setEnabled(True)
self.diff_radio.setEnabled(True)
self.gray_check.setEnabled(True)
self.equal_check.setEnabled(True)
self.map_radio.setEnabled(True)
self.change()
def load_file(self):
self.filename, basename, self.image = load_image(self)
if self.filename is None:
return
self.findChild(ToolTree, 'tree_widget').setEnabled(True)
self.findChild(QAction, 'prev_action').setEnabled(True)
self.findChild(QAction, 'next_action').setEnabled(True)
self.findChild(QAction, 'tile_action').setEnabled(True)
self.findChild(QAction, 'cascade_action').setEnabled(True)
self.findChild(QAction, 'close_action').setEnabled(True)
self.findChild(QAction, 'tabbed_action').setEnabled(True)
self.setWindowTitle('[{}] - {} {}'.format(
basename, QApplication.applicationName(), QApplication.applicationVersion()))
self.show_message(self.tr('Image "{}" successfully loaded'.format(basename)))
# FIXME: disable_bold della chiusura viene chiamato DOPO open_tool e nell'albero la voce NON diventa neretto
self.mdi_area.closeAllSubWindows()
self.open_tool(self.tree_widget.topLevelItem(0).child(0), None)
def get_image(self, name):
return load_image(name, reverse_order=not self.stock)
def load_file(self):
filename, basename, image = load_image(self)
if filename is None:
return
self.initialize(filename, basename, image)
def open_recent(self):
action = self.sender()
if action:
filename, basename, image = load_image(self, action.data())
self.initialize(filename, basename, image)
def get_image(self, name):
return load_image(name, reverse_order=not self.stock)
from utility import load_image, makeFolder, saveImage, saveFeatures, saveW
from rbm import RBM
if __name__ == '__main__':
data_path = 'data/4position_rumba/image_gray'
file_num = 3
isRGB = False
pre_train_lr = 0.1
pre_train_epoch = 10
# node_shape = ((80,52), (74,46), (35,21))
node_shape = ((80, 52), (74, 46), (34, 20))
filter_shift_list = ((1, 1), (2, 2))
input_shape = [80, 52]
filter_shape = [7, 7]
data_list = load_image(data_path, file_num, isRGB)
makeFolder()
# 時間計測
time1 = time.clock()
cnn1 = CNN(data_list, filter_shape, filter_shift_list[0], input_shape, node_shape[1], pre_train_lr, pre_train_epoch)
output_list = cnn1.output()
saveImage(output_list, node_shape[1], 'cnn1_before_training')
cnn1.pre_train()
output_list = cnn1.output()
saveImage(output_list, node_shape[1], 'cnn1_after_training')
from pygame import sprite, display, time, font, event
from pygame.locals import * # pylint: disable=wildcard-import, unused-wildcard-import
from gamemodels import Player, Goalkeeper, Ball
from utility import load_image, position_from_center
from constants import SCREEN_HEIGHT, SCREEN_WIDTH, WHITE, BLACK, BALL_SPEED, SCORE, counter
pygame.init()
FRAME_PER_SEC = time.Clock()
# Setting up Fonts
FONT = font.SysFont("Verdana", 60)
FONT_SMALL = font.SysFont("Verdana", 20)
GAME_OVER = FONT.render("Game Over", True, BLACK)
BACKGROUND = load_image("pitch640x484.png")
# Create a white screen
DISPLAYSURF = display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
DISPLAYSURF.fill(WHITE)
display.set_caption("Game")
# Setting up Sprites
P1 = Player()
E1 = Goalkeeper()
B1 = Ball()
# Creating Sprites Groups
# enemies = pygame.sprite.Group()
# enemies.add(E1)
ALL_SPRITES = sprite.Group()
device = 'cpu'
device = torch.device(device)
net = Net().to(device)
criterion = nn.L1Loss()
optimize = optim.Adam(filter(lambda p: p.requires_grad, net.parameters()), args.LR)
# ======================开始训练===========================
net.train()
iteration = dataset.get_step()
print("Batch_size=", args.BATCH_SIZE, "iteration=", iteration, "lr=", args.LR)
for iter in range(iteration):
# 获取 LR/HR 的图片路径
x_train, y_train = dataset.next_train_batch()
# 对数据进行处理，这里为了加快速度，每次只读一张图片，然后对一张图片进行batch_size次随机裁剪，得到一个batch
x_train, y_train = utility.load_image(x_train[0], y_train[0], batch_size = args.BATCH_SIZE, is_train=True)
# print("---------------------------------")
# print(x_train.shape, y_train.shape)
# 数据导入GPU
x_train = x_train.to(device)
y_train = y_train.to(device)
out = net(x_train)
loss = criterion(out, y_train)
optimize.zero_grad()
loss.backward()
optimize.step()
learning_rate = args.LR * (0.5 ** (iter // iteration)) # 迭代次数---降低学习率
for param_group in optimize.param_groups:
def __init__(self):
super().__init__()
self.image = load_image("Player.png")
self.surf = pygame.Surface((99, 126))
self.rect = self.surf.get_rect()
self.reset()
def main(winstyle=0):
pass
if pygame.get_sdl_version()[0] == 2:
pygame,mixwe.pre_init(44100, 32, 2, 1024)
pygame.init()
winstyle = 0 # |FULLSCREEN
bestdepth = pygame.desplay.mode_ok(SCREENRECT.size, winstyle, bestdepth)
bestdepth = pygame.display.mode_ok(SCREENRECT.size, winstyle, 32)
screen = pygame.display.set_mode(SCREENRECT.size, winstyle, bestdepth)
set_game_obj_images()
pygame.mouse.set_visible(0)
background_tile_image = utility.load_image("background.gif")
background = pygame.Surface(SCREENRECT.size)
for x_position in range(0, SCREENRECT.width,
background_tile_image.get_width()):
background.blit(background_tile_image, (x_position, 0))
screen.blit(background, (0, 0))
pygame.display.flip()
set_game_sound()
aliens = pygame.sprite.Group()
shots = pygame.sprite.Group()
bombs = pygame.sprite.Group()
all_game_rects = pygame.sprite.RenderUpdates()
last_alien = pygame.sprite.GroupSingle()
Player.containers = all_game_rects
Alien.containers = aliens, all_game_rects, last_alien
Shot.containers = shots, all_game_rects
Bomb.containers = bombs, all_game_rects
Explosion.containers = all_game_rects
Score.containers = all_game_rects
PlayerLives.containers = all_game_rects
Alien(SCREENRECT)
if (pygame.font is not None):
all_game_rects.add(Score())
all_game_rects.add(PlayerLives())
game_loop(all_game_rects, screen, background, shots,
last_alien, aliens, bombs, winstyle, bestdepth, FULLSCREEN)
if (pygame.mixer is not None):
pygame.mixer.music.fadeout(1000)
pygame.time.wait(1000)
pygame.quit()
image_size = 416
YOLOv3 = YOLO(config_path, image_size)
YOLOv3.load_weights(weight_path)
yolo_module_list = list(YOLOv3.children())[0]
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
place_holder = torch.randn(1, 3, 416, 416).to(device)
measurer = YOLOMeasurer(YOLOv3, yolo_module_list)
import sys
import re
import os
import gc
image_path = sys.argv[1]
image = load_image(image_path, image_size)
mean_Jacobian = measurer.compute_jacobian(image,
mode="reduction_mean_channel")
for i, derivative in enumerate(mean_Jacobian):
if derivative is not None:
mean_Jacobian[i] = derivative.norm().detach().cpu().numpy()
mean_Jacobian = np.array(mean_Jacobian)
save_path = "./"
file_save_path = save_path + re.search(r"[^/.]+/[^/.]+/([^/.]+)\.jpg$",
image_path)[0] + '.csv'
directory = re.search(r"(.+img1)", file_save_path)[1]
if not os.path.exists(directory):
os.makedirs(directory)
np.savetxt(file_save_path, mean_Jacobian, delimiter=",")
gc.collect()
if __name__ == '__main__':
try:
OUTPUT_DIR = ("output/" + content_name + "_vs_" + style_name)
os.mkdir(OUTPUT_DIR)
except:
pass
start_time = time.time()
with tf.device("/gpu:0"):
with tf.Session() as sess:
# Load images.
content_image = utility.load_image(CONTENT_IMAGE,
IMAGE_HEIGHT,
IMAGE_WIDTH,
invert=content_invert)
style_image = utility.load_image(STYLE_IMAGE,
IMAGE_HEIGHT,
IMAGE_WIDTH,
invert=style_invert)
# utility.save_image(OUTPUT_DIR+"/"+style_name+".png", style_image, invert = style_invert)
# Load the model.
model = model.load_vgg_model(VGG_MODEL, IMAGE_HEIGHT, IMAGE_WIDTH,
3)
# Content image as input image
initial_image = content_image.copy()
# Initialize all variables
sess.run(tf.global_variables_initializer())
