def sr_text(self, btn): image = utils.open_image('tmp/crop_little.png') utils.save_image('model/dcscn_text/crop_little.png', image) os.system('cd model/dcscn_text && python sr.py --file=crop_little.png --batch_image_size=18 --layers=18 --filters=196 --training_images=100000 --scale=8') image = utils.open_image('model/dcscn_text/output/dcscn_L18_F196to48_Sc8_NIN_A64_PS_R1F32/crop_little_result.png') utils.save_image('tmp/crop.png', image) self.sr_bool = True self.popup_crop.dismiss() self.image_onPress()
def generate_layer_list(res): img = open_image('1.jpg') img = torch.unsqueeze(img, 0) layer_list = [] index = 0 for layer in res: if isinstance(layer, torch.nn.modules.conv.Conv2d): temp_class = Layer('conv', img.shape, layer(img).shape, index, layer.kernel_size[0], layer.stride[0], index - 1) img = layer(img) elif isinstance(layer, torch.nn.modules.activation.ReLU): temp_class = Layer('ReLu', img.shape, layer(img).shape, index, 0, 0, index - 1) img = layer(img) elif isinstance(layer, torch.nn.modules.pooling.MaxPool2d): temp_class = Layer('pool', img.shape, layer(img).shape, index, layer.kernel_size, layer.stride, index - 1) img = layer(img) elif isinstance(layer, torch.nn.modules.dropout.Dropout): temp_class = Layer('Dropout', img.shape, layer(img).shape, index, 0, 0, index - 1) img = layer(img) elif isinstance(layer, torch.nn.modules.linear.Linear): img = img.view(-1) temp_class = Layer('FC', img.shape, layer(img).shape, index, 0, 0, index - 1) img = layer(img) layer_list.append(temp_class) index += 1 return layer_list
def main(): # Open Image File as a coloured image img = utils.open_image(settings.settingsImagePath) # Retrieve filtered image walls = utils.apply_vision_filter(img) ground = utils.apply_ground_filter(img) # Initialize Bot with startup settings bot = robot.Robot(x=settings.settingsStartX, y=settings.settingsStartY, direction=settings.settingsFaceDirection, wall_map=walls, ground_map=ground, no_of_squares_per_side=settings.settingsGridSideSquares, cell_side_length=len(img) // settings.settingsGridSideSquares) # Initialize user bot scripts src = settings.settingsSrcClass(bot) # Run setup src.setup() loop_img = numpy.copy(img) while True: # Refresh Screen utils.refresh_screen(loop_img, bot) # Loop loop_img = numpy.copy(img) ret = src.loop(loop_img) if ret == SimulationRunStatus.STOP_SIMULATION: # If stop simulation signal, Exit break
def __init__(self, path): self.com1 = enlace(serialName) self.com1.enable() self.img_array = open_image(path) self.l_bytes_img = separate_packages(self.img_array) self.l_packages = [] self.str_log = '' self.start_execution_time = 0
def add_reminders(img_path): img = open_image(img_path) ocr_text = ocr(img) menu_items = text_to_menu_items(ocr_text)[:4] for date, food in menu_items: add_reminder(date, food) return menu_items
def automatic_ai(self): image = utils.open_image('foo.png') image = utils.resize_image(image, 1280, 720) utils.save_image('model/CAR/input.jpg', image) os.system('cd model/CAR && python main.py input.jpg yolo') image = utils.open_image('model/CAR/result.jpg') image = utils.resize_image(image, 854, 480) utils.save_image('foo.png', image) self.ids.image_source.reload() positions = utils.get_car_positions() print('Cars positions: ' + str(positions)) cars = glob.glob('model/CAR/cars/*.png') plate.process_cars(cars) utils.clean_cars_folder()
def __getitem__(self, index): _file = self.files[index] file_path = self.train_dir / _file img = open_image(file_path) target = self.labels[index] if self.preproc is not None: img, target = self.preproc(img, target) return torch.from_numpy(img), torch.from_numpy(target)
def upload_file(): f = request.files['file'] mimetype = f.content_type print(mimetype) if mimetype == "image/jpeg0" or mimetype == "image/png": image = open_image(f) extracted_text = read_image(image) document = write_docx(extracted_text) print("okay") return send_file(document, as_attachment=True, attachment_filename="report.docx") elif mimetype == "audio/mpeg" or mimetype == "audio/wav": f.filename = "sound.wav" f.save(f.filename) stream = os.popen('python3 test_ffmpeg.py ' + f.filename) output = stream.read() print(output) text = '' with open('res.json') as json_file: data = json.load(json_file) text = data['text'] print(data['text']) extracted_text = text processed_text = convert_text(extracted_text) print(extracted_text + ';' + processed_text) response = make_response(extracted_text + ';' + processed_text, 200) response.mimetype = "text/plain" return response elif mimetype == "application/vnd.openxmlformats-officedocument.wordprocessingml.document": document = open_docx(f) extracted_text = read_docx(document) processed_text = convert_text(extracted_text) new_document = write_docx(processed_text) stream = save_docx(new_document) print("okay") response = make_response( send_file(stream, as_attachment=True, attachment_filename="report1to3.docx")) response.headers['word'] = 'yes' return response elif mimetype == "application/vnd.oasis.opendocument.text": extracted_text = open_odt(f) processed_text = convert_text(extracted_text) stream = write_odt(processed_text) print("okay") response = make_response( send_file(stream, as_attachment=True, attachment_filename="report1to3.odt")) response.headers['word'] = 'no' return response
def post(self): self.logger.info("Request to resize IMG for request file") args = self._get_args() for item in self.request.files.values(): for file_info in item: name = "/tmp/rs-%s-%s.png" % (time.time(), file_info["filename"]) resize(open_image(file_info["body"]), name, args) self.response_file(name) return
def _get_QRcode(self): url = 'https://qr.m.jd.com/show' payload = { 'appid': 133, 'size': 147, 't': str(int(time.time() * 1000)), } headers = { 'User-Agent': self.user_agent, 'Referer': 'https://passport.jd.com/new/login.aspx', } resp = self.sess.get(url=url, headers=headers, params=payload) if not response_status(resp): logger.info('获取二维码失败') return False QRCode_file = 'QRcode.png' save_image(resp, QRCode_file) logger.info('二维码获取成功,请打开京东APP扫描') open_image(QRCode_file) return True
def _get_auth_code(self, uuid): image_file = os.path.join(os.getcwd(), 'jd_authcode.jpg') url = 'https://authcode.jd.com/verify/image' payload = { 'a': 1, 'acid': uuid, 'uid': uuid, 'yys': str(int(time.time() * 1000)), } headers = { 'User-Agent': self.user_agent, 'Referer': 'https://passport.jd.com/uc/login', } resp = self.sess.get(url, params=payload, headers=headers) if not response_status(resp): logger.error('获取验证码失败') return '' save_image(resp, image_file) open_image(image_file) return input('验证码:')
def classify_image(img_path): img = open_image(img_path) ocr_text = ocr(img) if 'mosaicscience' in ocr_text: return 'mosaic' days_mentioned = [ token for line in ocr_text.split('\n') for token in line.split(' ') if token in DAYS ] if len(days_mentioned) > 5: return 'food' return 'trustnet'
def create_collage(image_filename): from multiprocessing import Pool, cpu_count from PIL import ImageDraw image = utils.open_image(image_filename) width, height = image.size n_palettes = len(palette.available_palettes) n_methods = len(available_methods) canvas_size = (width * (n_palettes + 1), height * (n_methods + 1)) canvas = Image.new('RGB', canvas_size) canvas.paste(image, (0, 0)) drawer = ImageDraw.Draw(canvas) font = _get_font(image.size) font_color = (255, 255, 255, 255) image_matrix = utils.pil2numpy(image) work_objects = [] for p_i, p in enumerate(palette.available_palettes): text_width, text_height = font.getsize(p) text_pos = ((p_i + 1) * width + (width - text_width) / 2, (height - text_height) / 2) drawer.text(text_pos, p, font=font, fill=font_color) for m_i, m in enumerate(available_methods): if p_i == 0: text_width, text_height = font.getsize(m) text_pos = ((width - text_width) / 2, (m_i + 1) * height + (height - text_height) / 2) drawer.text(text_pos, m, font=font, fill=font_color) image_offset = ((p_i + 1) * width, (m_i + 1) * height) work_objects.append((image_offset, image_matrix, m, p)) del drawer pool = Pool(cpu_count()) results = pool.map(_do_work, work_objects) for r in results: image_offset, dither_image = r canvas.paste(dither_image, image_offset) canvas.save('collage.png') canvas.show()
def draw_image_model(img_model, out_dir): # image = Image.open('background.png') im = utils.open_image(img_model['image_path']) # initialise the drawing context with # the image object as background # if the out dir doesnt exist the create it try: os.makedirs(out_dir) except OSError: pass image_draw = ImageDraw.Draw(im) # p_color = 'rgb(0, 0, 0)' # p_color = get_rgb_color(img_model['colors'],3) # p_shadowcolor = get_rgb_color(img_model['colors'],1) # p_color = get_darkest(img_model['colors']) # p_shadowcolor = get_brightest(img_model['colors']) p_color = make_rgb_string(img_model['colors'][2]) p_shadowcolor = make_rgb_string(img_model['colors'][3]) # the poem draw_paragraph(img_model['text'].replace('|','\n'), image_draw, img_model['font_path'], 10, 5, title_size=35, justify=False, line_width=25, color = p_color, shadowcolor = p_shadowcolor) # the id draw_img_id(img_model['id'], image_draw, img_model['font_path'], im.height, text_size=80, color = p_color, shadowcolor = p_shadowcolor) # sig draw_sig('@claytantor', image_draw, img_model['font_path'], im.height, im.width, text_size=25, color = p_color, shadowcolor = p_shadowcolor) out_img_path = '{}/{}'.format(out_dir, '{}.png'.format(img_model['id'])) print(out_img_path) im.save(out_img_path, "PNG", optimize=True, quality=20)
def find_mosaic_url(img=None, img_path=None): if img_path: img = open_image(img_path) img_title = read_title(img) print(img_title) mosaic_url = get_google_first_result(img_title) print(mosaic_url) if mosaic_url: mosaic_title = get_mosaic_title(mosaic_url) print(mosaic_title) similarity_score = calculate_title_similarity(mosaic_title, img_title) print(similarity_score) if similarity_score < 0.2: return "https://s3-us-west-2.amazonaws.com/hs-production-blog/blog/wp-content/uploads/2017/01/27124612/headspace_blog_wrong.gif" return mosaic_url return "https://cdn.dribbble.com/users/1554526/screenshots/3399669/no_results_found.png"
def __getitem__(self, idx): arr_accumFrameNum = np.add.accumulate(self.arr_videoFrameNum) # print("arr_accumFrameNum=", arr_accumFrameNum) idxVideo = np.searchsorted(arr_accumFrameNum, idx) # print("idxVideo=", idxVideo) if idxVideo == 0: idxFrame = idx else: idxFrame = idx - arr_accumFrameNum[idxVideo - 1] - 1 # starts from 0 videoFolder = self.list_videoFolders[idxVideo] # print("videoFolder=", videoFolder) list_img = sorted(glob.glob(videoFolder + "/*jpg")) inframes = list() for i in range(self.temp_psz): if idxFrame - self.ctrlfr_idx + i < 0: relidx = 0 elif idxFrame - self.ctrlfr_idx + i > len(list_img) - 1: relidx = len(list_img) - 1 else: relidx = idxFrame - self.ctrlfr_idx + i img, expanded_h, expanded_w = open_image(list_img[relidx],\ gray_mode=False) inframes.append(img) # list to numpy array inframes = np.stack(inframes, axis=0) # numpy to torch tensor inframes = torch.from_numpy(inframes[:, np.newaxis, :, :, :]).to( self.device) # target target = inframes[self.ctrlfr_idx] # Add noise noise = torch.empty_like(inframes).normal_(mean=0, std=self.noise_sigma).to( self.device) inframes = inframes + noise noisestd = torch.FloatTensor([self.noise_sigma]).to(self.device) return inframes, target, noisestd
def generator(X_train, y_train, batch_size, training=False): ''' Data generator used for training the model. - Reades images from path - Preprocess images - Augments training data only. ''' number_samples = len(y_train) while 1: shuffle(X_train, y_train) for offset in range(0, number_samples, batch_size): X, y = X_train[offset:offset + batch_size], y_train[offset:offset + batch_size] X = [utils.open_image(x) for x in X] X = [utils.pre_process(x) for x in X] if training: for i, (image, label) in enumerate(zip(X, y)): X[i] = utils.augment(image) X = np.array([keras_image.img_to_array(x) for x in X]) yield shuffle(X, y)
def load(self, path, filename): if(self.ids.toggle_video.state == 'down'): # video path self.video_file = os.path.join(path, filename[0]) # clean tmp frames folder files = glob.glob('tmp/frames/*') for f in files: os.remove(f) # loading the frames of the video cap = cv2.VideoCapture(self.video_file) currentFrame = 0 while(True): # Capture frame-by-frame ret, frame = cap.read() # if not ret: # break if currentFrame > 500: break # Saves image of the current frame in png file name = 'tmp/frames/' + str(currentFrame) + '.png' print('Creating...' + name) utils.save_image(name, frame) # To stop duplicate images currentFrame += 1 cap.release() if(self.ids.toggle_image.state == 'down'): # image path self.image_file = os.path.join(path, filename[0]) image = utils.open_image(self.image_file) # refresh image viewer widget utils.save_image('foo.png', image) self.ids.image_source.reload() self.dismiss_popup()
def handleKeyBinding(self): """Should have all keybinding handle here""" while True: if self.interface.resize_event: self.interface.handle_resize_event() self.interface.erase_flash_message() self.interface.display_timeline() ch = self.interface.screen.getch() # DOWN if ch == self.conf.keys["down"] or ch == curses.KEY_DOWN: self.interface.move_down() # UP elif ch == self.conf.keys["up"] or ch == curses.KEY_UP: self.interface.move_up() # LEFT elif ch == self.conf.keys["left"] or ch == curses.KEY_LEFT: self.interface.navigate_buffer(-1) # RIGHT elif ch == self.conf.keys["right"] or ch == curses.KEY_RIGHT: self.interface.navigate_buffer(+1) # TWEET elif ch == self.conf.keys["tweet"]: self.api.tweet() # RETWEET elif ch == self.conf.keys["retweet"]: self.api.retweet() # RETWEET AND EDIT elif ch == self.conf.keys["retweet_and_edit"]: self.api.retweet_and_edit() # DELETE TwEET elif ch == self.conf.keys["delete"]: self.api.destroy() # MENTIONS elif ch == self.conf.keys["mentions"]: self.interface.change_buffer("mentions") # HOME TIMELINE elif ch == self.conf.keys["home"]: self.interface.change_buffer("home") # CLEAR elif ch == self.conf.keys["clear"]: self.interface.clear_statuses() # UPDATE elif ch == self.conf.keys["update"]: self.api.update_timeline(self.interface.buffer) # FOLLOW SELECTED elif ch == self.conf.keys["follow_selected"]: self.api.follow_selected() # UNFOLLOW SELECTED elif ch == self.conf.keys["unfollow_selected"]: self.api.unfollow_selected() # FOLLOW elif ch == self.conf.keys["follow"]: self.api.follow() # UNFOLLOW elif ch == self.conf.keys["unfollow"]: self.api.unfollow() # OPENURL elif ch == self.conf.keys["openurl"]: self.interface.openurl() # BACK ON TOP elif ch == self.conf.keys["back_on_top"]: self.interface.back_on_top() # BACK ON BOTTOM elif ch == self.conf.keys["back_on_bottom"]: self.interface.back_on_bottom() # REPLY elif ch == self.conf.keys["reply"]: self.api.reply() # GET DIRECT MESSAGE elif ch == self.conf.keys["getDM"]: self.interface.change_buffer("direct") # SEND DIRECT MESSAGE elif ch == self.conf.keys["sendDM"]: self.api.direct_message() # SEARCH elif ch == self.conf.keys["search"]: self.api.search() # SEARCH USER elif ch == self.conf.keys["search_user"]: self.api.find_public_timeline() # SEARCH MYSELF elif ch == self.conf.keys["search_myself"]: self.api.my_public_timeline() elif ch == self.conf.keys["search_current_user"]: self.api.find_current_public_timeline() # Redraw screen elif ch == self.conf.keys["redraw"]: self.interface.display_redraw_screen() # Help elif ch == ord("?"): Help() # Create favorite elif ch == self.conf.keys["fav"]: self.api.set_favorite() # Get favorite elif ch == self.conf.keys["get_fav"]: self.api.get_favorites() # Destroy favorite elif ch == self.conf.keys["delete_fav"]: self.api.destroy_favorite() # Thread elif ch == self.conf.keys["thread"]: self.api.get_thread() # Open image elif ch == self.conf.keys["open_image"]: open_image(self.interface.current_status().user) # User info elif ch == ord("i"): self.interface.current_user_info() elif ch == self.conf.keys["waterline"]: self.interface.update_last_read_home() self.interface.back_on_top() # QUIT elif ch == self.conf.keys["quit"]: self.interface.stoped = True break else: continue self.interface.erase_flash_message() self.interface.display_timeline()
def main(args): epochs = args.epochs file_list = get_files('./data') num_samples = len(file_list) tf.reset_default_graph() sess = tf.InteractiveSession() optimal = sys.float_info.max style = np.zeros(BATCH_SIZE, dtype=np.float32) style[0] = open_image(args.style_image) with tf.Graph().as_default(), tf.Session() as sess: X_content = tf.placeholder(tf.float32, shape=BATCH_SIZE, name="X_content") X_style = tf.placeholder(tf.float32, shape=BATCH_SIZE, name="X_style") generated_image = net(X_content / 255.0) warmup_loss = tf.reduce_mean(tf.square(generated_image - X_content)) warmup_step = tf.train.AdamOptimizer(0.001).minimize(warmup_loss) loss = loss_func(sess, X_style, X_content, generated_image) train_step = tf.train.AdamOptimizer(0.00005).minimize(loss) sess.run(tf.global_variables_initializer()) if args.mode == 0: saver = tf.train.Saver() saver.restore(sess, './model/transform_net.ckpt') eval_batch = np.zeros(BATCH_SIZE, dtype=np.float32) eval_batch[0] = open_image(args.content_image) start_time = time.time() output = sess.run(generated_image, feed_dict={ X_style: style, X_content: eval_batch }) end_time = time.time() print("Time: %s" % str(end_time - start_time)) save_image(args.output_dir + "/generated_image.jpg", output) return print("Warming up...") for epoch in range(20): for i in range(num_samples): batch = np.zeros(BATCH_SIZE, dtype=np.float32) batch[0] = open_image(file_list[i]) feed_dict = {X_style: style, X_content: batch} sess.run(warmup_step, feed_dict=feed_dict) eval_batch = np.zeros(BATCH_SIZE, dtype=np.float32) eval_batch[0] = open_image(args.content_image) eval_loss = sess.run(warmup_loss, feed_dict={ X_style: style, X_content: eval_batch }) print("Epoch: %d, Loss: %f" % (epoch, eval_loss)) print("Start Training...") for epoch in range(args.epochs): for i in range(num_samples): batch = np.zeros(BATCH_SIZE, dtype=np.float32) batch[0] = open_image(file_list[i]) feed_dict = {X_style: style, X_content: batch} sess.run(train_step, feed_dict=feed_dict) eval_batch = np.zeros(BATCH_SIZE, dtype=np.float32) eval_batch[0] = open_image(args.content_image) start_time = time.time() eval_loss = sess.run(loss, feed_dict={ X_style: style, X_content: eval_batch }) end_time = time.time() change_time = end_time - start_time print("Epoch: %d, Loss: %f, Time: %s" % (epoch, eval_loss, str(change_time))) if optimal > eval_loss: saver = tf.train.Saver() res = saver.save(sess, './model/transform_net.ckpt') optimal = eval_loss if epoch % 10 == 0: output = sess.run(generated_image, feed_dict={ X_style: style, X_content: eval_batch }) save_image(args.output_dir + "/" + str(epoch) + ".jpg", output)
from DNN_model import Get_ResNet_50, Get_VGG_16 from utils import vertex_extract, open_image, Layer, VM, evaluate_performance import cv2 import cnn_finetune import torch import numpy as np img = open_image('1.jpg') img = torch.unsqueeze(img, 0) VGG_16 = Get_VGG_16() res = vertex_extract(VGG_16) #Divide Index divid_index = 19 index = 0 layer_list = [] for layer in res: if isinstance(layer, torch.nn.modules.conv.Conv2d): temp_class = Layer('conv', img.shape, layer(img).shape, index, layer.kernel_size[0], layer.stride[0], index - 1) img = layer(img) elif isinstance(layer, torch.nn.modules.activation.ReLU): temp_class = Layer('ReLu', img.shape, layer(img).shape, index, 0, 0, index - 1) img = layer(img) elif isinstance(layer, torch.nn.modules.pooling.MaxPool2d): temp_class = Layer('pool', img.shape, layer(img).shape, index, layer.kernel_size, layer.stride, index - 1) img = layer(img)
opr = utils.clamp(opr + random.gauss(0.0, 1./6.)) opg = utils.clamp(opg + random.gauss(0.0, 1./6.)) opb = utils.clamp(opb + random.gauss(0.0, 1./6.)) new_pixel = numpy.array(utils.closest_palette_color([opr, opg, opb], palette_name), dtype=numpy.float) new_matrix[x][y] = new_pixel return new_matrix _available_methods = OrderedDict([ ('random' , randomized), ('block_random' , block_randomized), ]) if __name__ == '__main__': import argparse parser = argparse.ArgumentParser() parser.add_argument('image_filename', help='Path to an image file to dither') parser.add_argument('-b', '--bit-depth', type=int, default=1, help='Number of bits in dithered image') palette_help_str = 'Name of palette to use. Can be one of: ' + ', '.join(palette.available_palettes) parser.add_argument('-p', '--palette', type=str, default=default_palette, help=palette_help_str) args = parser.parse_args() image = utils.open_image(args.image_filename) image_matrix = utils.pil2numpy(image) dither_matrix = randomized(image_matrix, args.palette) dither_image = utils.numpy2pil(dither_matrix) dither_image.show()
def train(FLAGS): shape = (FLAGS.image_height, FLAGS.image_width) content_img, style_img = utils.open_image( FLAGS.content_input, shape=shape), utils.open_image(FLAGS.style_input, shape=shape) with tf.Session() as sess: print('Calculating target content...') vgg = vgg16(img=content_img, train=False) sess.run(tf.global_variables_initializer()) vgg.load_weights(weight_file=FLAGS.model, sess=sess) content_target = sess.run(vgg.content_response()) print('Calculating target style...') vgg = vgg16(img=style_img, train=False) sess.run(tf.global_variables_initializer()) vgg.load_weights(weight_file=FLAGS.model, sess=sess) style_target = sess.run(vgg.style_response()) print('Begin training on ' + str((FLAGS.image_width, FLAGS.image_height)) + ' image...') vgg = vgg16(img=utils.white_noise(shape=shape + (3, )), train=True) loss = FLAGS.alpha * vgg.content_loss( content_target) + FLAGS.beta * vgg.style_loss( style_target) + FLAGS.gamma * vgg.noise_loss() train_op = vgg.training(loss, learning_rate=FLAGS.learning_rate) saver = tf.train.Saver() if FLAGS.checkpoint is not None: saver.restore(sess, FLAGS.checkpoint) print("Progress restored.") else: sess.run(tf.global_variables_initializer()) vgg.load_weights(weight_file=FLAGS.model, sess=sess) for step in range(FLAGS.max_steps): start_time = time.time() sess.run(train_op) duration = time.time() - start_time # Print status to stdout. if step % 20 == 0 or (step + 1) == FLAGS.max_steps: loss_value, content_loss, style_loss, noise_loss = sess.run([ loss, vgg.content_loss(content_target), vgg.style_loss(style_target), vgg.noise_loss() ]) print( 'Step %d: %.3f sec \n total_loss = %.3e \n content_loss = %.3e \n style_loss = %.3e \n noise_loss = %.3e' % (step, duration, loss_value, FLAGS.alpha * content_loss, FLAGS.beta * style_loss, FLAGS.gamma * noise_loss)) if (step + 1) % 100 == 0 or (step + 1) == FLAGS.max_steps: vgg.adjust() checkpoint_file = os.path.join(FLAGS.log_dir, 'model.ckpt') saver.save(sess, checkpoint_file) output_file = str( time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())) + '.png' output_file = os.path.join(FLAGS.output_dir, output_file) image = vgg.img.eval() image = np.asarray(image[0, :, :, :], dtype='uint8') utils.save_image(output_file, image)
def __init__(self, content_path, style_path, output_path, loss_ratio=1e-3, verbose=True, save_every_n_iters=10, initial_canvas='content'): """ intialize all things for style transfer the overall process is as follows: 1. image preprocessing 2. define loss functions for content representations and style representations 3. define evaluation function for training loss and gradients Args: content_image_path (str): The path for the content image style_image_path (str): The path for the style image loss_ratio (float): alpha divided by beta (beta is defined as 1) verbose (bool): True for print states, False otherwise save_every_n_steps: save images every n steps initial_canvas (str): the initial canvas for generated images. Choice in {'random', 'content', 'style'} """ self.output_path = output_path self.save_every_n_iters = save_every_n_iters self.initial_canvas = initial_canvas self.verbose = verbose self.step = 0 content_layer = DEFAULT_CONTENT_LAYER style_layers = DEFAULT_STYLE_LAYERS # load the style and content images content_img = utils.open_image(content_path) self.img_shape = (content_img.shape[0], content_img.shape[1], 3) self.content_img = utils.preproc(content_img) self.style_img = utils.preproc( utils.open_image(style_path, self.img_shape)) content_img = K.variable(self.content_img) style_img = K.variable(self.style_img) # define a placeholder for a generated image if K.image_data_format() == 'channels_first': generated_img = K.placeholder( (1, 3, self.img_shape[0], self.img_shape[1])) else: generated_img = K.placeholder( (1, self.img_shape[0], self.img_shape[1], 3)) # create a keras tensor for the input input_tensor = K.concatenate([content_img, style_img, generated_img], axis=0) # load VGG16 with the weights pretrained on imagenet. # ! the original paper uses vgg19 and replaces its all max_pooling to avg_pooling. vgg16 = VGG16(input_tensor=input_tensor, include_top=False, input_shape=self.img_shape) # outputs of each layer outputs_dict = {layer.name: layer.output for layer in vgg16.layers} # loss for the content image content_feat = outputs_dict[content_layer][0] generat_feat = outputs_dict[content_layer][2] feat_size, ch_size = utils.get_feat_channel_size(generat_feat) # ! the original paper suggests 'divided by 2' # the following denominator is from: # from https://github.com/cysmith/neural-style-tf/blob/master/neural_style.py content_loss = K.sum(K.square(content_feat - generat_feat)) \ / (2. * feat_size * ch_size) # loss for the style image. style_loss = K.variable(0.) style_loss_weight = 1. / len(style_layers) for style_layer in style_layers: style_feat = outputs_dict[style_layer][1] generat_feat = outputs_dict[style_layer][2] feat_size, ch_size = utils.get_feat_channel_size(generat_feat) style_loss += style_loss_weight * \ K.sum(K.square(utils.gram_matrix(style_feat) - \ utils.gram_matrix(generat_feat))) / \ (4. * feat_size ** 2 * ch_size ** 2) # composite loss beta = 1 alpha = loss_ratio * beta content_loss = alpha * content_loss style_loss = beta * style_loss total_loss = content_loss + style_loss # gradients grads = K.gradients(total_loss, generated_img) # evaluation function self.eval_fn = K.function( [generated_img], [total_loss, content_loss, style_loss] + grads)
# This is the hopefully faster approach to training a generator # network. import config256 as config import generation_network import keras.backend as K from keras.layers import Input from keras.models import load_model import keras.engine.topology as topology import numpy as np import utils # Load source image. content_target_image = utils.open_image( config.CONTENT_PHOTO_PATH, vggify=False, ) content_target_image /= 255.0 generation_model = generation_network.build(input_shape=config.DIMS) generation_model.load_weights(config.MODEL_PATH) stylized_image = generation_model.predict( np.expand_dims(content_target_image, axis=0)) utils.save_image(0, stylized_image, image_shape=config.DIMS, unvggify=False)
def keystroke(self, ch): if not self.interface.help: # Quit if ch == self.conf.keys['quit']: self.interface.stoped = True raise urwid.ExitMainLoop() # Right elif ch == self.conf.keys['right'] or ch == 'right': self.interface.navigate_buffer(+1) # left elif ch == self.conf.keys['left'] or ch == 'left': self.interface.navigate_buffer(-1) elif ch == self.conf.keys['up']: self.interface.go_up() elif ch == self.conf.keys['down']: self.interface.go_down() # Update elif ch == self.conf.keys['update']: self.api.update_timeline(self.interface.buffer) # Tweet elif ch == self.conf.keys['tweet']: self.interface.edit_status('tweet', prompt='Tweet ') # Reply elif ch == self.conf.keys['reply']: self.interface.reply() # Retweet elif ch == self.conf.keys['retweet']: self.api.retweet() # Retweet and Edit elif ch == self.conf.keys['retweet_and_edit']: self.api.retweet_and_edit() # Delete elif ch == self.conf.keys['delete']: self.api.destroy() # Mention timeline elif ch == self.conf.keys['mentions']: self.interface.change_buffer('mentions') # Home Timeline elif ch == self.conf.keys['home']: self.interface.change_buffer('home') # Direct Message Timeline elif ch == self.conf.keys['getDM']: self.interface.change_buffer('direct') # Clear statuses elif ch == self.conf.keys['clear']: self.interface.clear_statuses() # Follow Selected elif ch == self.conf.keys['follow_selected']: self.api.follow_selected() # Unfollow Selected elif ch == self.conf.keys['unfollow_selected']: self.api.unfollow_selected() # Follow elif ch == self.conf.keys['follow']: self.interface.edit_status('follow', prompt='Follow') # Unfollow elif ch == self.conf.keys['unfollow']: self.interface.edit_status('unfollow', prompt='Unfollow ') # Open URL elif ch == self.conf.keys['openurl']: self.interface.openurl() # Search elif ch == self.conf.keys['search']: self.interface.edit_status('search', prompt='Search ') # Search User elif ch == self.conf.keys['search_user']: self.interface.edit_status('public', prompt='Nick ') # Search Myself elif ch == self.conf.keys['search_myself']: self.api.my_public_timeline() # Search Current User elif ch == self.conf.keys['search_current_user']: self.api.find_current_public_timeline() # Send Direct Message #FIXME #elif ch == self.conf.keys['sendDM']: #self.api.direct_message() # Create favorite elif ch == self.conf.keys['fav']: self.api.set_favorite() # Get favorite elif ch == self.conf.keys['get_fav']: self.api.get_favorites() # Destroy favorite elif ch == self.conf.keys['delete_fav']: self.api.destroy_favorite() # Thread elif ch == self.conf.keys['thread']: self.api.get_thread() # Open image elif ch == self.conf.keys['open_image']: open_image(self.interface.current_status().user) # User info elif ch == 'i': self.interface.current_user_info() # Waterline elif ch == self.conf.keys['waterline']: self.interface.update_last_read_home() # Back on Top elif ch == self.conf.keys['back_on_top']: self.interface.back_on_top() # Back on Bottom elif ch == self.conf.keys['back_on_bottom']: self.interface.back_on_bottom() # Help elif ch == '?': self.interface.display_help() self.interface.display_timeline() else: if ch in ('q', 'Q', 'esc'): urwid.emit_signal(self, 'help_done')
def keystroke (self, ch): if not self.interface.help: # Quit if ch == self.conf.keys['quit']: self.interface.stoped = True raise urwid.ExitMainLoop() # Right elif ch == self.conf.keys['right'] or ch == 'right': self.interface.navigate_buffer(+1) # left elif ch == self.conf.keys['left'] or ch == 'left': self.interface.navigate_buffer(-1) elif ch == self.conf.keys['up']: self.interface.go_up() elif ch == self.conf.keys['down']: self.interface.go_down() # Update elif ch == self.conf.keys['update']: self.api.update_timeline(self.interface.buffer) # Tweet elif ch == self.conf.keys['tweet']: self.interface.edit_status('tweet', prompt='Tweet ') # Reply elif ch == self.conf.keys['reply']: self.interface.reply() # Retweet elif ch == self.conf.keys['retweet']: self.api.retweet() # Retweet and Edit elif ch == self.conf.keys['retweet_and_edit']: self.api.retweet_and_edit() # Delete elif ch == self.conf.keys['delete']: self.api.destroy() # Mention timeline elif ch == self.conf.keys['mentions']: self.interface.change_buffer('mentions') # Home Timeline elif ch == self.conf.keys['home']: self.interface.change_buffer('home') # Direct Message Timeline elif ch == self.conf.keys['getDM']: self.interface.change_buffer('direct') # Clear statuses elif ch == self.conf.keys['clear']: self.interface.clear_statuses() # Follow Selected elif ch == self.conf.keys['follow_selected']: self.api.follow_selected() # Unfollow Selected elif ch == self.conf.keys['unfollow_selected']: self.api.unfollow_selected() # Follow elif ch == self.conf.keys['follow']: self.interface.edit_status('follow', prompt='Follow') # Unfollow elif ch == self.conf.keys['unfollow']: self.interface.edit_status('unfollow', prompt='Unfollow ') # Open URL elif ch == self.conf.keys['openurl']: self.interface.openurl() # Search elif ch == self.conf.keys['search']: self.interface.edit_status('search', prompt='Search ') # Search User elif ch == self.conf.keys['search_user']: self.interface.edit_status('public', prompt='Nick ') # Search Myself elif ch == self.conf.keys['search_myself']: self.api.my_public_timeline() # Search Current User elif ch == self.conf.keys['search_current_user']: self.api.find_current_public_timeline() # Send Direct Message #FIXME #elif ch == self.conf.keys['sendDM']: #self.api.direct_message() # Create favorite elif ch == self.conf.keys['fav']: self.api.set_favorite() # Get favorite elif ch == self.conf.keys['get_fav']: self.api.get_favorites() # Destroy favorite elif ch == self.conf.keys['delete_fav']: self.api.destroy_favorite() # Thread elif ch == self.conf.keys['thread']: self.api.get_thread() # Open image elif ch == self.conf.keys['open_image']: open_image(self.interface.current_status().user) # User info elif ch == 'i': self.interface.current_user_info() # Waterline elif ch == self.conf.keys['waterline']: self.interface.update_last_read_home() # Back on Top elif ch == self.conf.keys['back_on_top']: self.interface.back_on_top() # Back on Bottom elif ch == self.conf.keys['back_on_bottom']: self.interface.back_on_bottom() # Help elif ch == '?': self.interface.display_help() self.interface.display_timeline() else: if ch in ('q', 'Q', 'esc'): urwid.emit_signal(self, 'help_done')
def save(self, path, filename): image = utils.open_image('tmp/crop.png') utils.save_image(os.path.join(path, filename), image) self.dismiss_popup()
def handleKeyBinding(self): '''Should have all keybinding handle here''' while True: if self.interface.resize_event: self.interface.handle_resize_event() self.interface.erase_flash_message() self.interface.display_timeline() ch = self.interface.screen.getch() # DOWN if ch == self.conf.keys['down'] or ch == curses.KEY_DOWN: self.interface.move_down() # UP elif ch == self.conf.keys['up'] or ch == curses.KEY_UP: self.interface.move_up() # LEFT elif ch == self.conf.keys['left'] or ch == curses.KEY_LEFT: self.interface.navigate_buffer(-1) # RIGHT elif ch == self.conf.keys['right'] or ch == curses.KEY_RIGHT: self.interface.navigate_buffer(+1) # TWEET elif ch == self.conf.keys['tweet']: self.api.tweet() # RETWEET elif ch == self.conf.keys['retweet']: self.api.retweet() # RETWEET AND EDIT elif ch == self.conf.keys['retweet_and_edit']: self.api.retweet_and_edit() # DELETE TwEET elif ch == self.conf.keys['delete']: self.api.destroy() # MENTIONS elif ch == self.conf.keys['mentions']: self.interface.change_buffer('mentions') # HOME TIMELINE elif ch == self.conf.keys['home']: self.interface.change_buffer('home') # CLEAR elif ch == self.conf.keys['clear']: self.interface.clear_statuses() # UPDATE elif ch == self.conf.keys['update']: self.api.update_timeline(self.interface.buffer) # FOLLOW SELECTED elif ch == self.conf.keys['follow_selected']: self.api.follow_selected() # UNFOLLOW SELECTED elif ch == self.conf.keys['unfollow_selected']: self.api.unfollow_selected() # FOLLOW elif ch == self.conf.keys['follow']: self.api.follow() # UNFOLLOW elif ch == self.conf.keys['unfollow']: self.api.unfollow() # OPENURL elif ch == self.conf.keys['openurl']: self.interface.openurl() # BACK ON TOP elif ch == self.conf.keys['back_on_top']: self.interface.back_on_top() # BACK ON BOTTOM elif ch == self.conf.keys['back_on_bottom']: self.interface.back_on_bottom() # REPLY elif ch == self.conf.keys['reply']: self.api.reply() # GET DIRECT MESSAGE elif ch == self.conf.keys['getDM']: self.interface.change_buffer('direct') # SEND DIRECT MESSAGE elif ch == self.conf.keys['sendDM']: self.api.direct_message() # SEARCH elif ch == self.conf.keys['search']: self.api.search() # SEARCH USER elif ch == self.conf.keys['search_user']: self.api.find_public_timeline() # SEARCH MYSELF elif ch == self.conf.keys['search_myself']: self.api.my_public_timeline() elif ch == self.conf.keys['search_current_user']: self.api.find_current_public_timeline() # Redraw screen elif ch == self.conf.keys['redraw']: self.interface.display_redraw_screen() # Help elif ch == ord('?'): Help() # Create favorite elif ch == self.conf.keys['fav']: self.api.set_favorite() # Get favorite elif ch == self.conf.keys['get_fav']: self.api.get_favorites() # Destroy favorite elif ch == self.conf.keys['delete_fav']: self.api.destroy_favorite() # Thread elif ch == self.conf.keys['thread']: self.api.get_thread() # Open image elif ch == self.conf.keys['open_image']: open_image(self.interface.current_status().user) # User info elif ch == ord('i'): self.interface.current_user_info() # QUIT elif ch == self.conf.keys['quit']: break else: continue self.interface.erase_flash_message() self.interface.display_timeline()
def image_onPress(self): if self.sr_bool is False: # get mouse coordinates x, y = utils.xy_calc(Window.mouse_pos) # assert x, y x = utils.clamp(x, crop_px, win_x - crop_px) y = utils.clamp(y, crop_px, win_y - crop_px) # crop around mouse position image = utils.open_image('foo.png') image = utils.crop_image(image, int(x), int(y), crop_px) utils.save_image('tmp/crop_little.png', image) image = utils.click_resize_image(image, 8) utils.save_image('tmp/crop.png', image) # building popup box_popup = GridLayout(cols=1) box_image = GridLayout(cols=1, size_hint=(1, .8)) img_widget = Image(id='imagem', source='tmp/crop.png') img_widget.reload() box_image.add_widget(img_widget) box_popup.add_widget(box_image) box_control = GridLayout(cols=5, size_hint=(1, .2)) btn1 = Button(text="Detect Plate", bold=True) btn2 = Button(text="SR - Face", bold=True) btn3 = Button(text="SR - Text", bold=True) btn4 = Button(text="Save Image", bold=True) btn5 = Button(text="Close", bold=True) btn1.bind(on_press=self.pop_up_get_plate) btn2.bind(on_press=self.sr_face) btn3.bind(on_press=self.sr_text) btn4.bind(on_press=self.show_save) btn5.bind(on_press=self.close_popup_crop) box_control.add_widget(btn1) box_control.add_widget(btn2) box_control.add_widget(btn3) box_control.add_widget(btn4) box_control.add_widget(btn5) box_popup.add_widget(box_control) else: print(self.sr_bool) # building popup box_popup = GridLayout(cols=1) box_image = GridLayout(cols=1, size_hint=(1, .8)) img_widget = Image(id='imagem', source='tmp/crop.png') img_widget.reload() box_image.add_widget(img_widget) box_popup.add_widget(box_image) box_control = GridLayout(cols=3, size_hint=(1, .2)) btn1 = Button(text="Detect Plate", bold=True) btn2 = Button(text="Save Image", bold=True) btn3 = Button(text="Close", bold=True) btn1.bind(on_press=self.pop_up_get_plate) btn2.bind(on_press=self.show_save) btn3.bind(on_press=self.close_popup_crop) box_control.add_widget(btn1) box_control.add_widget(btn2) box_control.add_widget(btn3) box_popup.add_widget(box_control) # creating popup self.popup_crop = Popup( title='Image', content=box_popup, size=(384, 480)) self.popup_crop.open()
from utils import open_image, separate_packages from datagram import Datagram img = open_image('imgs/advice.png') pkgs = separate_packages(img) for i in pkgs: header_list = [1 for i in range(10)] a = Datagram(payload=[], header_list=header_list).get_datagram() print(a) break