def __init__(self, data_directory): super(DatasetFromFolder, self).__init__() self.input_img_path = join(data_directory, 'input_img') self.gt_img_path = join(data_directory, 'gt_img') self.input_img_filenames = [x for x in listdir(self.input_img_path) if is_image_file(x)] self.input_img_filenames.sort() self.gt_img_filenames = [x for x in listdir(self.gt_img_path) if is_image_file(x)] self.gt_img_filenames.sort() transform_list = [transforms.ToTensor(),] self.transform = transforms.Compose(transform_list)
def default(self): """ Default action fetches all the stats and renders a template using them """ stats = {} # get all the thumbnails stats["Database stats"] = [ ("Number of marked files", Photo.get_num_marked_photos(), "raw"), ("Number of DB files", Photo.get_count_by_date(), "raw") ] stats["File System stats"] = [] for s in [Photo.SMALL_THUMB_SIZE, Photo.MEDIUM_THUMB_SIZE]: stats["File System stats"].extend(self._thumb_info(s)) num_images = 0 total_size = 0 for root, dirs, files in os.walk(S.BASE_FS_PATH): for f in files: if util.is_image_file(f): num_images += 1 total_size += os.path.getsize(os.path.join(root, f)) stats["File System stats"].extend([ ("Number of source images", num_images, "raw"), ("Disk space", total_size, "bytes") ]) return self.construct_response(Template.render("stats.html", {"stats": stats}))
def __init__(self, image_dir): super(DatasetFromFolder, self).__init__() self.a_path = join(image_dir, "a") self.b_path = join(image_dir, "b") self.image_filenames = [ x for x in listdir(self.a_path) if is_image_file(x) ]
def add_image_sequence(zip_file_path, video_name): # unzip the file to the extract path zip_ref = zipfile.ZipFile(zip_file_path) info_list = zip_ref.infolist() # create folder in upload timestamp = str(long(time.time())) upload_folder = config.UPLOAD_PATH + timestamp + '/' if not os.path.exists(upload_folder): os.makedirs(upload_folder) path_list = [] for info in info_list: file_name = info.filename _, file_extension = os.path.splitext(file_name) if util.is_image_file(file_name): file_path = zip_ref.extract(info, path=upload_folder) path_list.append(file_path) # now, all image paths are stored in the path_list # then extract these images extract_path = config.EXTRACT_PATH + os.path.splitext( basename(zip_file_path))[0] logger.debug('extract sequence begin %s' % extract_path) if not os.path.exists(extract_path): os.makedirs(extract_path) turkic_replacement.extract_image_sequences(path_list, extract_path) logger.debug('extract video end %s' % extract_path) # delete the temporary unzip path shutil.rmtree(upload_folder) # there is no label by default turkic_replacement.load(video_name, extract_path, [], zip_file_path, current_user.id)
def default(self): """ Default action fetches all the stats and renders a template using them """ stats = {} # get all the thumbnails stats["Database stats"] = [ ("Number of marked files", Photo.get_num_marked_photos(), "raw"), ("Number of DB files", Photo.get_count_by_date(), "raw") ] stats["File System stats"] = [] for s in [Photo.SMALL_THUMB_SIZE, Photo.MEDIUM_THUMB_SIZE]: stats["File System stats"].extend(self._thumb_info(s)) num_images = 0 total_size = 0 for root, dirs, files in os.walk(S.BASE_FS_PATH): for f in files: if util.is_image_file(f): num_images += 1 total_size += os.path.getsize(os.path.join(root, f)) stats["File System stats"].extend([ ("Number of source images", num_images, "raw"), ("Disk space", total_size, "bytes") ]) return self.construct_response( Template.render("stats.html", {"stats": stats}))
def __init__(self, image_dir, mode, xy_size, img_size, norm, rotated=0, val=False): super(DatasetFromFolder, self).__init__() if 'no'==norm.partition('-')[2]: self.b ="b" else: self.b ="b_uniform" if mode=="AtoB": self.photo_path = join(image_dir, "a") self.sketch_path = join(image_dir, self.b) else: self.photo_path = join(image_dir, self.b) self.sketch_path = join(image_dir, "a") self.image_filenames = [x for x in listdir(self.photo_path) if is_image_file(x)] self.img_size = img_size self.val = val self.rgb = False if xy_size > 0 else True #Training self.rotated=rotated self.norm = norm.partition('-')[0] if norm!='' else 'linear' #self.location_map = make_grid(1, img.size[0], img.size[1], norm=norm) as parameter in place of norm, so one time calculated& oft used # mean and std for Cityscapes CITYSCAPES_MEAN = [0.28689554, 0.32513303, 0.28389177] CITYSCAPES_STD = [0.18696375, 0.19017339, 0.18720214] transform_list = [transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))] self.transform = transforms.Compose(transform_list)
def __init__(self, image_dir, tranform=None): super(DataSetFromFolder, self).__init__() self.image_dir = image_dir self.image_filenames = [ x for x in listdir(image_dir) if is_image_file(x) ] if transform: self.transform = transform
def preview(self): """ Presents a preview of the files to be imported, giving the user an opportunity to view and change dates for images, highlighting images which may already be in the system, and the like. """ rel_import_dir = os.path.relpath( self._env.get("PATH_INFO", "").lstrip("/"), "import/preview") import_dir = os.path.realpath( os.path.join(S.IMPORT_DIR, rel_import_dir)) file_listing = [] import_identifier = hashlib.sha1() hashes = [] session_file_struct = {} for base_dir, _, files in os.walk(import_dir): for f in files: if not util.is_image_file(f): continue fc = util.FileContainer(os.path.join(import_dir, f), S.IMPORT_DIR) ts = util.get_time(fc, allow_date_from_path=False) if ts["time"] != None: fc.time = time.strftime("%Y-%m-%d %H:%M:%S", ts["time"]) hashes.append(fc.hash) import_identifier.update(fc.hash) file_listing.append(fc) session_file_struct[fc.hash] = { "file_data": fc.__dict__(), "conflicts": None } break file_listing = sorted(file_listing, key=itemgetter('name')) conflicts = Photo.get_by_hash(hashes) for conflict_hash in conflicts.keys(): conflicts_for_json = [c.id for c in conflicts[conflict_hash]] session_file_struct[conflict_hash][ "conflicts"] = conflicts_for_json session_file_struct[conflict_hash]["file_data"]["marked"] = True Logger.debug(session_file_struct) session_id = import_identifier.hexdigest() session_data = { "file_listing": session_file_struct, "rel_dir": rel_import_dir, "session_id": session_id } with open(os.path.join("/tmp", "%s.txt" % session_id), "w+") as f: f.write(json.dumps(session_data)) return self.construct_response( Template.render( "import/preview.html", { "files": file_listing, "import_id": session_id, "import_dir": rel_import_dir, "conflicts": conflicts }), self._route_types.HTML_CONTENT_TYPE)
def preview(self): """ Presents a preview of the files to be imported, giving the user an opportunity to view and change dates for images, highlighting images which may already be in the system, and the like. """ rel_import_dir = os.path.relpath(self._env.get("PATH_INFO", "").lstrip("/"), "import/preview") import_dir = os.path.realpath(os.path.join(S.IMPORT_DIR, rel_import_dir)) file_listing = [] import_identifier = hashlib.sha1() hashes = [] session_file_struct = {} for base_dir, _, files in os.walk(import_dir): for f in files: if not util.is_image_file(f): continue fc = util.FileContainer(os.path.join(import_dir, f), S.IMPORT_DIR) ts = util.get_time(fc, allow_date_from_path=False) if ts["time"] != None: fc.time = time.strftime("%Y-%m-%d %H:%M:%S", ts["time"]) hashes.append(fc.hash) import_identifier.update(fc.hash) file_listing.append(fc) session_file_struct[fc.hash] = { "file_data": fc.__dict__(), "conflicts": None } break file_listing = sorted(file_listing, key=itemgetter('name')) conflicts = Photo.get_by_hash(hashes) for conflict_hash in conflicts.keys(): conflicts_for_json = [c.id for c in conflicts[conflict_hash]] session_file_struct[conflict_hash]["conflicts"] = conflicts_for_json session_file_struct[conflict_hash]["file_data"]["marked"] = True Logger.debug(session_file_struct) session_id = import_identifier.hexdigest() session_data = { "file_listing": session_file_struct, "rel_dir": rel_import_dir, "session_id": session_id } with open(os.path.join("/tmp", "%s.txt" % session_id), "w+") as f: f.write(json.dumps(session_data)) return self.construct_response( Template.render( "import/preview.html", { "files": file_listing, "import_id": session_id, "import_dir": rel_import_dir, "conflicts": conflicts } ), self._route_types.HTML_CONTENT_TYPE )
def get_all_image_details_in_dir(img_dir): file_names_list = os.listdir(img_dir) for file_name in file_names_list: # Only those files that are image files are considered. if (util.is_image_file(file_name)): file_full_path = os.path.join(img_dir, file_name) with Image.open(file_full_path) as img: yield (file_name, img.size)
def get_matching_image_details(img_dir, keyword): file_names_list = os.listdir(img_dir) matching_file_names_list = util.get_matching_files(file_names_list, keyword) for file_name in matching_file_names_list: if (util.is_image_file(file_name)): file_full_path = os.path.join(img_dir, file_name) with Image.open(file_full_path) as img: yield (file_name, img.size)
def __init__(self, image_dir): super(DatasetFromFolder, self).__init__() self.photo_path = join(image_dir, "a") self.sketch_path = join(image_dir, "b") self.image_filenames = [x for x in listdir(self.photo_path) if is_image_file(x)] transform_list = [transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))] self.transform = transforms.Compose(transform_list)
def classids(): img_dir = "dataset/spherical/" cl_dir = "dataset/spherical2/" #np_img =np.zeros((512,3,1024)) image_filenames = [x for x in os.listdir(img_dir) if is_image_file(x)] for image_name in image_filenames: np_img = load_img(img_dir + image_name, (1024, 512), rgb=True) image = encode_img_ids(np_img) #image = classify(np_img, img=False) save_img_np(decode_ids(image), cl_dir + image_name, (1024, 512))
def make_dataset(txt_file): image = [] path_all = pd.read_table(txt_file, header=None, delim_whitespace=True) for i in range(len(path_all)): img_lr = path_all.iloc[i, 0] img_hr = path_all.iloc[i, 1] # img_sr = path_all.iloc[i, 2] if is_image_file(img_lr): item = (img_lr, img_hr) image.append(item) return image
def __init__(self, image_dir): super(DatasetFromFolder, self).__init__() self.input_path = join(image_dir, "input") self.output_path = join(image_dir, "output") self.image_filenames = [ x for x in listdir(self.output_path) if is_image_file(x) ] # transform_list = [transforms.ToTensor(), # transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))] transform_list = [transforms.ToTensor()] self.transform = transforms.Compose(transform_list)
def default(self): """ Fetches a list of directories, files, or some combination thereof which need to be imported. The specific path is assumed from the PATH_INFO provided by self._env """ rel_import_dir = os.path.relpath( self._env.get("PATH_INFO", "").lstrip("/"), "import") dir_to_show = os.path.join(S.IMPORT_DIR, rel_import_dir) file_listing = [] dir_listing = [] get_details = True total_files = 0 for base_dir, dirs, files in os.walk(dir_to_show): if get_details: for d in dirs: dir_listing.append({ "rel_path": os.path.relpath(os.path.join(base_dir, d), S.IMPORT_DIR), "friendly_name": d }) dir_listing = sorted(dir_listing, key=itemgetter("friendly_name")) for f in files: if not util.is_image_file(f): continue total_files += 1 if not get_details: continue fc = util.FileContainer(os.path.join(base_dir, f), base_dir) time_resp = util.get_time(fc, allow_date_from_path=False) if time_resp["time"] != None: fc.time = time.strftime(util.EXIF_DATE_FORMAT, time_resp["time"]) file_listing.append(fc) get_details = False file_listing = sorted(file_listing, key=itemgetter('name')) return self.construct_response( Template.render( "import/listing.html", { "dirs": dir_listing, "files": file_listing, "total_files": total_files, "current_dir": rel_import_dir }), self._route_types.HTML_CONTENT_TYPE)
def __init__(self, image_dir): super(DatasetFromFolder, self).__init__() self.content_path = join(image_dir, "content") self.style_path = join(image_dir, "style") self.target_path = join(image_dir, "target") self.image_filenames = [ x for x in listdir(self.target_path) if is_image_file(x) ] transform_list = [ transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ] self.transform = transforms.Compose(transform_list)
def __init__(self, image_dir, imageSize): super(DatasetFromFolder, self).__init__() self.photo_path = image_dir self.image_filenames = [ x for x in listdir(self.photo_path) if is_image_file(x) ] transform_list = [ transforms.Grayscale(num_output_channels=1), transforms.Resize(imageSize), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ] self.transform = transforms.Compose(transform_list)
def upload_file(): if request.method == 'POST': # check if the post request has the file part if 'file' not in request.files: flash('No file part') return redirect(request.url) file = request.files['file'] # if user does not select file, browser also # submit a empty part without filename if file.filename == '': flash('No selected file') return redirect(request.url) if file and util.is_image_file(file.filename): filename = secure_filename(file.filename) file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename)) return redirect(url_for('upload_file', filename=filename)) return render_template('upload.html')
def default(self): """ Fetches a list of directories, files, or some combination thereof which need to be imported. The specific path is assumed from the PATH_INFO provided by self._env """ rel_import_dir = os.path.relpath(self._env.get("PATH_INFO", "").lstrip("/"), "import") dir_to_show = os.path.join(S.IMPORT_DIR, rel_import_dir) file_listing = [] dir_listing = [] get_details = True total_files = 0 for base_dir, dirs, files in os.walk(dir_to_show): if get_details: for d in dirs: dir_listing.append({ "rel_path": os.path.relpath(os.path.join(base_dir, d), S.IMPORT_DIR), "friendly_name": d }) dir_listing = sorted(dir_listing, key=itemgetter("friendly_name")) for f in files: if not util.is_image_file(f): continue total_files += 1 if not get_details: continue fc = util.FileContainer(os.path.join(base_dir, f), base_dir) time_resp = util.get_time(fc, allow_date_from_path=False) if time_resp["time"] != None: fc.time = time.strftime(util.EXIF_DATE_FORMAT, time_resp["time"]) file_listing.append(fc) get_details = False file_listing = sorted(file_listing, key=itemgetter('name')) return self.construct_response( Template.render("import/listing.html", { "dirs": dir_listing, "files": file_listing, "total_files": total_files, "current_dir": rel_import_dir }) , self._route_types.HTML_CONTENT_TYPE )
def __init__(self, image_dir, transform=None): super(DatasetFromFolder, self).__init__() if "flowers" in image_dir: self.image_dir = 'dataset/flowers/' with open("dataset/flowers/train/char-CNN-RNN-embeddings.pickle", "rb") as f: self.embeddings = pickle.load(f, encoding='latin1') with open("dataset/flowers/train/filenames.pickle", "rb") as f: filenames = pickle.load(f, encoding='latin1') #filenames = [ (filename[:10] + '0' + filename[10:]) for filename in filenames] self.image_filenames = [ "{}.jpg".format(filename) for filename in filenames ] else: self.image_dir = image_dir self.image_filenames = [ x for x in listdir(image_dir) if is_image_file(x) ] if transform: self.transform = transform
# Testing settings parser = argparse.ArgumentParser(description='pix2pix-PyTorch-implementation') parser.add_argument('--dataset', required=True, help='facades') parser.add_argument('--model', type=str, default='checkpoint/facades/netG_model_epoch_200.pth', help='model file to use') parser.add_argument('--cuda', action='store_true', help='use cuda') opt = parser.parse_args() print(opt) netG = torch.load(opt.model) #read the black and white image image_dir = "dataset/{}/test/bw/".format(opt.dataset) image_filenames = [x for x in os.listdir(image_dir) if is_image_file(x)] transform_list = [ transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ] transform = transforms.Compose(transform_list) for image_name in image_filenames: img = load_img(image_dir + image_name) img = transform(img) input = Variable(img, volatile=True).view(1, -1, 256, 256) if opt.cuda: netG = netG.cuda()
def __init__(self, image_dir): super(DatasetFromFolder, self).__init__() self.a_path = join(image_dir, "a") self.b_path = join(image_dir, "b") self.image_filenames = [x for x in listdir(self.a_path) if is_image_file(x)]
def main(photo_file_dir): rotate_list = [] box_list = [] left_eye_list = [] right_eye_list = [] resize_scales = [] target_files = [] file_list = os.listdir(photo_file_dir) pd_size = 100 for filename in file_list: if util.is_image_file(filename): photo_file = photo_file_dir + '/' + filename print photo_file response = util.face_detection(photo_file, True) detected = 0 try: for faces in response['responses'][0]['faceAnnotations']: detected = detected + 1 except KeyError: continue except IndexError: continue if detected > 0: face = response['responses'][0]['faceAnnotations'][0] print 'rollAngle: %s' % face['rollAngle'] print 'panAngle: %s' % face['panAngle'] # if abs(face['panAngle']) > 30: # continue print 'tiltAngle: %s' % face['tiltAngle'] # if abs(face['tiltAngle']) > 30: # continue print 'detectionConfidence: %s' % face['detectionConfidence'] if face['detectionConfidence'] < 0.6: continue landmarks = face['landmarks'] for pos in landmarks: x = pos['position']['x'] y = pos['position']['y'] if pos['type'] == 'LEFT_EYE_PUPIL': left_eye_pos = (x, y) left_eye_list.append(left_eye_pos) if pos['type'] == 'RIGHT_EYE_PUPIL': right_eye_pos = (x, y) right_eye_list.append(right_eye_pos) # 瞳孔間距離の計算 pupil_distance = math.sqrt( (right_eye_pos[1] - left_eye_pos[1])**2 + (right_eye_pos[0] - left_eye_pos[0])**2) print 'pupilDistance: %s' % pupil_distance resize_scales.append(pd_size / pupil_distance) # 顔の領域を計算 fdBoundingPoly = [(v['x'], v['y']) for v in face['fdBoundingPoly']['vertices']] expansion_rate = 1 if util.use_google_face_detection(): expansion_rate = 1 # 顔の領域を拡大 cloudvisionの場合はpupil_distance分拡大、dlibの場合もpupil_distance分拡大 pd_int = int(round(pupil_distance * expansion_rate)) im = cv2.imread(photo_file) (im_x, im_y) = im.shape[:2] startx = max(0, fdBoundingPoly[0][0] - pd_int) starty = max(0, fdBoundingPoly[0][1] - pd_int) end_x = min(im_x, fdBoundingPoly[2][0] + pd_int) end_y = min(im_y, fdBoundingPoly[2][1] + pd_int) box_list.append((startx, starty, end_x, end_y)) # 右目を支点とした左目の位置の傾きを計算 radian = math.atan2( left_eye_pos[1] - right_eye_pos[1], right_eye_pos[0] - left_eye_pos[0]) print 'rotate degree: %s' % math.degrees(radian) rotate_list.append(radian) target_files.append(photo_file) else: print "Face not found: %s" % photo_file # アフィン変換実行 moved_left_eye = (200.0, 250.0) for (photo_file, left_eye, radian, resize) in zip(target_files, left_eye_list, rotate_list, resize_scales): dirname = os.path.dirname(photo_file) filename = os.path.basename(photo_file) if util.is_image_file(filename): root, ext = os.path.splitext(filename) affined_file = util.face_work_dir() + '/affined/' + root + '-affine' + ext cosr = np.cos(radian) sinr = np.sin(radian) rot = np.matrix(( (cosr * resize, -sinr * resize), (sinr * resize, cosr * resize) )) vec = np.array(left_eye) roteye = np.dot(rot, vec) move = (moved_left_eye[0] - roteye[0, 0], moved_left_eye[1] - roteye[0, 1]) matrix = [ [cosr * resize, -sinr * resize, move[0]], [sinr * resize, cosr * resize, move[1]] ] affine_matrix = np.float64(matrix) im = cv2.imread(photo_file) size = im.shape[:2] im_affine = cv2.warpAffine( im, affine_matrix, size, flags=cv2.INTER_LANCZOS4) crop_img = im_affine[0:512, 0:512] cv2.imwrite(affined_file, crop_img) symlink(affined_file, util.taken_date(photo_file)) return 0
def __init__(self, image_dir): self.a_path = join(image_dir, "a") self.b_path = join(image_dir, "b") self.image_filenames = [ x for x in listdir(self.a_path) if is_image_file(x) ]
parser = argparse.ArgumentParser(description='pix2pix-PyTorch-implementation') parser.add_argument('--dataset', required=True, help='cuhk') parser.add_argument('--model', type=str, required=True, help='model file to use') parser.add_argument('--input_nc', type=int, default=3, help='input image channels') parser.add_argument('--output_nc', type=int, default=3, help='output image channels') parser.add_argument('--ngf', type=int, default=64, help='generator filters in first conv layer') parser.add_argument('--cuda', action='store_true', help='use cuda') opt = parser.parse_args() print(opt) # opt.input_nc, opt.output_nc, opt.ngf netG_state_dict = torch.load(opt.model) netG = G(opt.input_nc, opt.output_nc, opt.ngf) netG.load_state_dict(netG_state_dict) image_dir = "dataset/{}/val_2018/".format(opt.dataset) image_filenames = [x for x in os.listdir(image_dir) if is_image_file(x)] batchsize=2 for image_name in image_filenames: img, shape = load_img(image_dir + image_name) input_x_np = np.zeros((batchsize, 3, 128, 128)).astype(np.float32) input_x_np[0,:] = np.asarray(img[0]) input= Variable(torch.from_numpy(input_x_np)) if opt.cuda: netG = netG.cuda() input = input.cuda()
def dump_image_and_label_files(video_ids, label_name_array, remove_none_frame=False): if not os.path.exists(config.IMAGE_LIST_PATH): os.makedirs(config.IMAGE_LIST_PATH) if not os.path.exists(config.LABEL_LIST_PATH): os.makedirs(config.LABEL_LIST_PATH) if not os.path.exists(config.LABEL_NAME_PATH): os.makedirs(config.LABEL_NAME_PATH) print 'specified labels ' + str(label_name_array) timestamp = str(long(time.time())) image_file_path = config.IMAGE_LIST_PATH + timestamp + '.txt' label_file_path = config.LABEL_LIST_PATH + timestamp + '.txt' label_name_path = config.LABEL_NAME_PATH + timestamp + '.txt' session = db.session image_list_array = [] label_list_array = [] for video_id in video_ids: video, data = getdata(video_id) total_frames = video.totalframes extract_path = video.extract_path # for each video, we create a dict, to store all necessary labels # the key is the label name, the value is an array, since there might be multiple boxes for one label label_dict = {} for track in data: print 'get track with name %s, and length %s ' % (str( track.label), str(len(track.boxes))) if str(track.label) in label_name_array: if str(track.label) not in label_dict: label_dict[str(track.label)] = [] label_dict[str(track.label)].append(track.boxes) # after the traverse, w get all valid labels for that video iterators = [] for label_name in label_name_array: if label_name in label_dict: iterators.append(label_dict[label_name]) else: iterators.append([]) # generate labels for each frame for frame in range(0, total_frames): img_path = Video.getframepath(frame, extract_path) if os.path.exists(img_path) and util.is_image_file(img_path): image_list_array.append(img_path) # traverse through the iterators, to check each label current_frame_labels = [] # each iterator represent the pointer for the array of the class for i, iterator in enumerate(iterators): label_boxes = [] for j, box_total in enumerate(iterator): if frame >= len(box_total): continue box = box_total[frame] # ignore these lost, occluded, generated labels if box.lost or box.occluded: continue x1 = box.xtl y1 = box.ytl w = (box.xbr - box.xtl) h = (box.ybr - box.ytl) item = [str(x1), str(y1), str(w), str(h)] label_boxes.append(item) current_frame_labels.append(label_boxes) # generate the format for that frame of labels label_list_array.append( generate_frame_label(current_frame_labels)) if remove_none_frame: filled_image_list_array = [] filled_label_list_array = [] for i, frame_item in enumerate(label_list_array): # traverse through the frame, if there is no label exist, remove it if len(frame_item) >= len(label_name_array): # the length should be at least the length of a rect filled_image_list_array.append(image_list_array[i]) filled_label_list_array.append(frame_item) else: print 'not labeled' print 'before remove none labeled array: length: %s, after %s' % (str( len(image_list_array)), str(len(filled_image_list_array))) image_list_array = filled_image_list_array label_list_array = filled_label_list_array total_frames = len(image_list_array) print 'total length of image %s, length of label %s, total frames %s' % ( str(len(image_list_array)), str( len(label_list_array)), str(total_frames)) util.write_list_to_file(image_list_array, image_file_path) util.write_list_to_file(label_list_array, label_file_path) # create the labels.txt file util.write_list_to_file(label_name_array, label_name_path) session.commit() return image_file_path, label_file_path, label_name_path
anti_aliasing=True) # io.imshow(crop_resized) # io.show() im_comb = np.concatenate((im / 255., crop_resized), axis=0) return im_comb if __name__ == '__main__': # Specify the folder of tested images folder = './result/ipiu/1/' # Specify the top-left and bottom-right corners of the interested area start = (141, 231) end = (275, 330) # start = (146, 124) # end = (272, 234) # start = (150, 0) # end = (200, 50) # start = (200, 240) # end = (240, 275) hr_list = [ join(folder, x) for x in sorted(listdir(folder)) if util.is_image_file(x) ] for fname in hr_list: im = io.imread(fname) # plt.imshow(im) # plt.show() im_expand = bbox_expand(im, start, end) name = os.path.basename(fname) io.imsave(join(folder, 'bbox_{}'.format(name)), im_expand)