class ImagesStorage(AbstractStorage):
defaults = {
'wall': load_image('box.png', prefix=r"..\..\data"),
'empty': load_image('grass.png', prefix=r"..\..\data"),
'player': load_image('mario.png', prefix=r"..\..\data"),
}
@classmethod
def create_singleton(cls):
return ImagesStorage()
def test_vgg(fn, vgg19=False):
print('test_vgg', fn)
x = tf.placeholder(dtype='float32', shape=[None, 224, 224, 3])
if vgg19:
model = modelPath19
else:
model = modelPath16
vgg16 = vgg.Vgg(x, 1000, vgg19, model)
prob = vgg16.build(False)
img = utils.load_image(fn, 224, 224)
Mean = np.array([103.939, 116.779, 123.68])
img = img - Mean
batch1 = img.reshape([1, 224, 224, 3])
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
sess.run(tf.global_variables_initializer())
vgg16.loadModel(sess)
out = sess.run(prob, feed_dict={x: batch1})[0][0]
classes_num = len(out)
print(classes_num)
import data.vgg_classes as classes
pred = np.argsort(out)
for i in range(5):
index = classes_num - i - 1
print(pred[index], out[pred[index]],
classes.class_names[pred[index]])
def __init__(self,
surface,
image_name,
coord_to_blit,
scale=None,
resize_to=None):
self.surface = surface
self.image = utils.load_image(image_name)
self.coord_to_blit = coord_to_blit
self.scale = scale
self.resize_to = resize_to
self.image_rect = self.image.get_rect()
self.image_rect.topleft = coord_to_blit
if self.scale is not None:
self.image = pygame.transform.smoothscale(
self.image,
(
self.image.get_size()[0] * self.scale,
self.image.get_size()[1] * self.scale,
),
)
elif self.resize_to is not None:
self.image = pygame.transform.smoothscale(self.image,
self.resize_to)
self.image.convert()
def minibatch(file_list, batchsize, w, h):
length = len(file_list)
i = 0
epoch = 0
random.shuffle(file_list)
while True:
if i + batchsize >= length:
random.shuffle(file_list)
epoch += 1
i = 0
images = []
labels = []
for j in xrange(i, i + batchsize):
content = file_list[j]
npos = content.index(',')
path = content[:npos]
classid = content[npos + 1:len(content) - 1]
image = utils.load_image(path, w, h)
index = classes_id.index(classid)
label = np.zeros(len(classes_id), dtype=np.int)
label[index] = 1
images.append(image)
labels.append(label)
i += batchsize
images = np.array(images, dtype=np.float32)
labels = np.array(labels, dtype=np.float32)
yield epoch, images, labels
def try_to_ocr(path, gauss_w, gauss_h, treshold):
try:
image_context = ImageContext(load_image(path), gauss_h, gauss_w, treshold)
digitCnts = get_digit_contours(get_contours_of_image(image_context.image))
digits = [str(digit) for digit in get_digits_from_digit_contours(get_digit_map(), digitCnts, image_context.image)]
return digits
except Exception:
return []
def test_load_image():
images_list = get_images_list("images")
for image_name in images_list:
image = load_image(image_name, path_to_folder="images", bgr2rgb=True)
assert len(image.shape) == 3, f"error in {image_name}"
assert image.shape[2] == 3, f"error in {image_name}"
assert image.max() <= 255, f"error in {image_name}"
assert image.min() >= 0, f"error in {image_name}"
def read_prediction_gt(dname, fnames):
images = []
for fname in fnames:
fname = os.path.join(dname, fname)
image = load_image(fname)
image = normalize(image)
images.append(image)
return torch.stack(images, dim=0)
def main(args):
logging.info("Started loading image.")
image = load_image(args.input_file)
logging.info("Finished loading image.")
segmentation_function = SEGMENTATION_TECHNIQUES[args.segmentation]
logging.info("Started image segmentation.")
segmented_image = segmentation_function(image)
logging.info("Finished image segmentation.")
num_segments = np.max(segmented_image)
print(f"Number of detected jigsaw pieces: {num_segments}.")
for i in range(1, num_segments + 1):
logging.info(f"Start processing segment {i}.")
subimage = segmented_image == i
cutout = get_cutout(subimage)
total_space = np.sum(cutout)
best_space = 0
space_target = 0.8
while best_space <= space_target * total_space:
boundaries, corners = get_boundaries_and_corners(
cutout, num_candidates=args.corner_candidates
)
space_target -= 0.05
possible_rectangles = find_rectangle_candidates(
cutout, corners, candidate_limit=10
)
best_rectangle = find_best_rectangle(possible_rectangles)
zeros = np.zeros_like(cutout)
for p in best_rectangle:
zeros[p[0], p[1]] = 1
best_space = np.sum(convex_hull_image(zeros) * cutout)
logging.info(
f"Current space is {best_space} which is {best_space / total_space} of total space. "
f"Required space is {space_target}."
)
boundary_points = np.argwhere(boundaries == 1)
new_boundary_points, classes = classify_points(best_rectangle, boundary_points)
description = get_object_description(
best_rectangle,
new_boundary_points,
classes,
center_of_mass(cutout),
None,
center_thr=12,
max_thr=75,
)
print(f"Figure_{i}'s code is {description}.")
center = center_of_mass(subimage)
logging.info(f"Saving image to output.png")
draw_type(image, center, description)
image.save("output.png")
def get_output_image(self, content_path, style_path, options: dict):
start_time = time.time()
style_content_model = VGG19Model(CONTENT_LAYERS, STYLE_LAYERS)
content_image, style_image = [
load_image(path) for path in (content_path, style_path)
]
image = tf.Variable(get_white_noise_image(tf.shape(content_image)[1:])) \
if options['white_noise_input'] else tf.Variable(content_image)
style_targets = style_content_model(style_image)['style_outputs']
content_targets = style_content_model(content_image)['content_outputs']
opt = tf.keras.optimizers.Adam(learning_rate=options['learning_rate'],
beta_1=0.99,
epsilon=1e-1)
style_content_model.compile(opt)
for epoch in range(options['epochs']):
for step in range(options['steps']):
style_content_model.fit(
image,
content_targets=content_targets,
style_targets=style_targets,
content_layer_weights=[1],
style_layer_weights=options['style_layer_weights'],
content_weight=options['content_weight'],
style_weight=options['style_weight'],
variation_weight=options['variation_weight'])
self.update_state(state='PROGRESS',
meta={
'current':
options['steps'] * epoch + step,
'total':
options['steps'] * options['epochs'],
'elapsed_time':
"{:.1f}s".format(time.time() - start_time)
})
output_path = Path('./static/output') / (str(self.request.id) + '.png')
save_image(image, Path(output_path))
return {
'output_path': str(output_path),
'total_time': "{:.1f}s".format(time.time() - start_time)
}
def main(): args = arguments() model = SmoothImageApprox(latent_size=args.latent_size).to(device) image = load_image(args.image, [args.size, args.size]) save_image(f"outputs/fieldgan_ref.png", image) image = image.permute(2, 0, 1) # use same image for content and loss. D = StyleTransfer(image[None, ...], image[None, ...]).to(device) image = image.to(device) init_image = model.init_zero(image.permute(1,2,0)) save_image(f"outputs/fieldgan_init.png", init_image) opt = optim.Adam(model.displacement.parameters(), lr=1e-3, weight_decay=0) #opt = optim.Adam(model.parameters(), lr=1e-3, weight_decay=0) train(model, image, D, opt, args) # TODO render the image after, fixing a latent noise and iterating through time test(model, args)
def __init__(self, game_class):
super().__init__(game_class)
# Initializes buttons, like MenuState
self.buttons = {
"pause_button": (
[
ImageButton(self.screen,
"pause.png", (750, 0),
resize_to=(50, 50)),
ImageButton(self.screen,
"play.png", (750, 0),
resize_to=(50, 50)),
],
NotImplemented,
)
}
# Initializes other important components.
# NOTE: Some will be converted to lists, to obtain multiple entities of that
self.pause_menu = PauseMenu(game_class)
self.background = utils.load_image("bg.png").convert()
self.player = Player()
self.enemy = enemy.BulletEnemy(self.player)
self.shop = ShopEntity()
self.test_hp = HealthBar(300, 300, 30, 5, 50, 100, 0, (128, 128, 128),
(100, 100, 100), 1)
# Currently, each tile is a 800x600 pixel image. May be changed to a square (possibly 25x25) soon
self.map = [
[1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1],
]
# Sets some commonly used gamewide data
game_data.player = self.player
game_data.player_list["main_player"] = self.player
game_data.playing_substate = self
game_data.current_substate = self
def main(_argv):
flags.mark_flag_as_required("model")
flags.mark_flag_as_required("image")
flags.mark_flag_as_required("labels")
labels = read_label_pbtxt(FLAGS.labels)
start_time = time.time()
tf.keras.backend.clear_session()
model = tf.saved_model.load(FLAGS.model)
end_time = time.time()
logging.info("model loaded")
logging.info(f"Elapsed time: {str(end_time - start_time)}sec")
image_np = load_image(FLAGS.image)
image_tensor = np.expand_dims(image_np, axis=0)
image_tensor = preprocess_input(image_tensor)
height, width, _ = image_np.shape
start_time = time.time()
detections = model(image_tensor)
end_time = time.time()
boxes = detections["detection_boxes"][0].numpy()
classes = detections["detection_classes"][0].numpy().astype(np.int32)
scores = detections["detection_scores"][0].numpy()
output_image = draw_boxes(
image_np.copy(),
boxes,
classes,
scores,
labels,
height,
width,
min_threshold=FLAGS.threshold,
)
output_image = cv2.cvtColor(output_image, cv2.COLOR_BGR2RGB)
cv2.imwrite(FLAGS.output, output_image)
cv2.imshow("Object Detection", output_image)
cv2.waitKey(0)
logging.info(f"Elapsed time: {str(end_time - start_time)}sec")
def stylize(args):
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# Loads image
content = load_image(args.content).to(device)
with torch.no_grad():
# Load Transformer net
style_model = TransformerNet()
state_dict = torch.load(args.model)
# Load Model Weights
style_model.load_state_dict(state_dict)
style_model.eval().to(device)
# Forward through Image Transformation Network
out = style_model(content).cpu()
# Save result image
save_image(out, args.out)
def test(args):
"""Stylize a content image"""
device = torch.device("cuda" if args.cuda else "cpu")
transformer = TransformerNet().to(device)
if args.model:
transformer.load_state_dict(torch.load(args.model))
content_transform = transforms.Compose([
transforms.Resize(args.content_size),
transforms.CenterCrop(args.content_size),
transforms.ToTensor(),
transforms.Lambda(lambda x: x.mul(255))
])
content_image = utils.load_image(args.content_image)
content_image = content_transform(content_image)
content_image = content_image.unsqueeze(0).to(device)
output = transformer(content_image).cpu().detach()
utils.save_image(args.output_image, output[0] * 255)
def image_edit(args):
image_path = args.data_path
# args.save_dir = "D:/Pycharm PRoject/open_cv/data/save/images"
ch = convex_Hull()
sd = ShapeDetector()
unified = []
image = load_image(image_path)
blurred = filter_image(image)
mask = hsv_mask(blurred)
contours = find_contours(mask)
status = ch.contours_status(contours)
contour_list = ch.contour_array(status)
hull = ch.convex_hull(contour_list, contours)
unified.append(hull)
unified = np.array(unified, dtype=np.int32)
shape = sd.detect(hull)
sd.print_shape_parameters(shape)
# print("Shape", shape)
area = contour_avg_area(contours)
if area >= 15:
width = 5
elif area < 15:
width = 1
draw_contours(image, unified, width=width)
if args.save_dir is not None:
if not os.path.exists(args.save_dir):
print(
"The directory: %s doesnot exist,........ making directory: %s"
% (args.save_dir, args.save_dir))
os.makedirs(args.save_dir)
save_image(image,
args.save_dir + "/" + args.save_image,
unified,
width=width)
def load(self):
debugger("Assets: load: Loading all game assets")
self.FLAPPY_UP_IMAGE = load_image('flappy-up.png', colorkey=None, alpha=True)
self.FLAPPY_MIDDLE_IMAGE = load_image('flappy-middle.png', colorkey=None, alpha=True)
self.FLAPPY_DOWN_IMAGE = load_image('flappy-down.png', colorkey=None, alpha=True)
self.PIPE_TOP_IMAGE = load_image('yellow-cable-top.png')
self.PIPE_BODY_IMAGE = load_image('yellow-cable-body.png')
self.BACKGROUND_DAY_COLOR = (49, 64, 70)
self.BACKGROUND_DAY_IMAGE = load_image('background.png')
self.GROUND_IMAGE = load_image('ground.png')
# sounds downloaded under CCO License from http://www.freesound.org/
# some of these have been edited to fit the game
self.GAME_OVER_SOUND = load_sound('game-over.wav')
self.START_GAME_SOUND = load_sound('game-start.wav')
self.FLAPPY_FLAP_SOUND = load_sound('jump.wav')
self.GAINED_POINT_SOUND = load_sound('point.wav')
def app():
st.title('Albumantations Demo App')
st.markdown(f'Albumentations Version: {A.__version__}')
# Select Image
st.subheader('Image')
image_files = glob.glob('./image/*')
image_files = ['Upload'] + [os.path.basename(path) for path in image_files]
image_name = st.selectbox('Select Pic', image_files)
# Load Image
img = load_image(image_name)
if img is not None:
st.subheader('Image Info')
st.markdown(f'(Height, Width) : ({img.shape[0]}, {img.shape[1]})')
# Setting Sidebar
with open('config.yml') as file:
cfg = yaml.safe_load(file)
transforms = get_transform(cfg)
# Display Image -----------------------------------------------------
display_images(img, transforms)
def train(args):
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
transform = transforms.Compose([
transforms.Resize(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)
# Loads transformer, vgg
transformer = TransformerNet().to(device)
mse_loss = torch.nn.MSELoss()
tv_loss = TVLoss(args.tv_weight).to(device)
optimizer = optim.Adam(transformer.parameters(), args.learning_rate)
if LOSS_NETWORK == 'vgg16':
vgg = VGG16(STYLE_LAYERS, CONTENT_LAYER,
requires_grad=False).to(device)
else:
vgg = VGG19(STYLE_LAYERS, CONTENT_LAYER,
requires_grad=False).to(device)
# Loads style image
style = load_image(args.style, args.batch_size).to(device)
# Computes style
features_style, _ = vgg(normalize_batch(style, args.norm_range))
gram_style = [gram_matrix(y)
for _, y in features_style.items()]
# Save paths
style_name = args.style.split('/')[-1].split('.')[0]
checkpoint_file = os.path.join(args.checkpoint_dir,
'{}.pth'.format(style_name))
# Training Algorithm
for epoch in range(args.epochs):
transformer.train()
c_loss = 0.
s_loss = 0.
for batch_id, (x, _) in tqdm(enumerate(train_loader), unit=' batches'):
x = x.to(device)
n_batch = len(x)
optimizer.zero_grad()
pred = transformer(x)
y = normalize_batch(pred, args.norm_range)
x = normalize_batch(x, args.norm_range)
features_y, content_y = vgg(y)
features_x, content_x = vgg(x)
# Content Loss
content_loss = args.content_weight * \
mse_loss(content_y[CONTENT_LAYER], content_x[CONTENT_LAYER])
# Style Loss
style_loss = 0.0
features_y = [feature for _,
feature in features_y.items()]
for ft_y, gm_s in zip(features_y, gram_style):
gm_y = gram_matrix(ft_y)
style_loss += mse_loss(gm_y, gm_s[:n_batch, :, :])
style_loss *= args.style_weight
# Tv Loss
tv = tv_loss(pred)
# Back Propogation
total_loss = content_loss + style_loss + tv
total_loss.backward()
optimizer.step()
c_loss += content_loss.item()
s_loss += style_loss.item()
if (batch_id + 1) % args.log_interval == 0:
tqdm.write('[{}] ({})\t'
'content: {:.6f}\t'
'style: {:.6f}\t'
'total: {:.6f}'.format(epoch+1, batch_id+1,
c_loss /
(batch_id + 1),
s_loss /
(batch_id + 1),
(c_loss + s_loss) / (batch_id + 1)))
# Saves a Checkpoint
if (batch_id + 1) % args.save_interval == 0:
transformer.eval().cpu()
tqdm.write('Checkpoint {}'.format(checkpoint_file))
torch.save(transformer.state_dict(), checkpoint_file)
transformer.to(device).train()
# Save Model
transformer.eval().cpu()
torch.save(transformer.state_dict(), checkpoint_file)
print("Finshed! Trained Model saved at", checkpoint_file)
def fast_train(args):
"""Fast training"""
device = torch.device("cuda" if args.cuda else "cpu")
transformer = TransformerNet().to(device)
if args.model:
transformer.load_state_dict(torch.load(args.model))
vgg = Vgg16(requires_grad=False).to(device)
global mse_loss
mse_loss = torch.nn.MSELoss()
content_weight = args.content_weight
style_weight = args.style_weight
lr = args.lr
content_transform = transforms.Compose([
transforms.Resize(args.content_size),
transforms.CenterCrop(args.content_size),
transforms.ToTensor(),
transforms.Lambda(lambda x: x.mul(255))
])
content_dataset = datasets.ImageFolder(args.content_dataset,
content_transform)
content_loader = DataLoader(
content_dataset,
batch_size=args.iter_batch_size,
sampler=InfiniteSamplerWrapper(content_dataset),
num_workers=args.n_workers)
content_loader = iter(content_loader)
style_transform = transforms.Compose([
transforms.Resize((args.style_size, args.style_size)),
transforms.ToTensor(),
transforms.Lambda(lambda x: x.mul(255))
])
style_image = utils.load_image(args.style_image)
style_image = style_transform(style_image)
style_image = style_image.unsqueeze(0).to(device)
features_style = vgg(
utils.normalize_batch(style_image.repeat(args.iter_batch_size, 1, 1,
1)))
gram_style = [utils.gram_matrix(y) for y in features_style]
if args.only_in:
optimizer = Adam([
param
for (name, param) in transformer.named_parameters() if "in" in name
],
lr=lr)
else:
optimizer = Adam(transformer.parameters(), lr=lr)
for i in trange(args.update_step):
contents = content_loader.next()[0].to(device)
features_contents = vgg(utils.normalize_batch(contents))
transformed = transformer(contents)
features_transformed = vgg(utils.standardize_batch(transformed))
loss, c_loss, s_loss = loss_fn(features_transformed, features_contents,
gram_style, content_weight,
style_weight)
optimizer.zero_grad()
loss.backward()
optimizer.step()
# save model
transformer.eval().cpu()
style_name = os.path.basename(args.style_image).split(".")[0]
save_model_filename = style_name + ".pth"
save_model_path = os.path.join(args.save_model_dir, save_model_filename)
torch.save(transformer.state_dict(), save_model_path)
