def merge_images_in_folders(path_input1, path_input2, path_output, mask='*.png,*.jpg', rotate_first=False): tools_IO.remove_files(path_output, create=True) fileslist1 = tools_IO.get_filenames(path_input1, mask) fileslist2 = tools_IO.get_filenames(path_input2, mask) fileslist1.sort() fileslist2.sort() for filename1, filename2 in zip(fileslist1, fileslist2): image1 = cv2.imread(path_input1 + filename1) image2 = cv2.imread(path_input2 + filename2) if image1 is None or image2 is None: continue if rotate_first: image1 = numpy.transpose(image1, [1, 0, 2]) shape1 = image1.shape shape2 = image2.shape image2_resized = cv2.resize( image2, (int(shape1[0] * shape2[1] / shape2[0]), shape1[0])) image = numpy.zeros( (shape1[0], shape1[1] + image2_resized.shape[1], shape1[2]), dtype=numpy.uint8) image[:, :shape1[1]] = tools_image.desaturate(image1) image[:, shape1[1]:] = image2_resized cv2.imwrite(path_output + filename1, image) return
def merge_images_in_folders_temp(path_input1, path_input2, path_output, mask='*.png,*.jpg'): tools_IO.remove_files(path_output, create=True) fileslist1 = tools_IO.get_filenames(path_input1, mask) fileslist2 = tools_IO.get_filenames(path_input2, mask) fileslist1.sort() fileslist2.sort() for filename1, filename2 in zip(fileslist1, fileslist2): image1 = cv2.imread(path_input1 + filename1) image2 = cv2.imread(path_input2 + filename2) if image1 is None or image2 is None: continue image1 = cv2.resize(image1, (640, 320)) image2 = cv2.resize(image2, (640, 320)) red = 0 * image2.copy() red[:, :, 2] = 255 weight = image2.copy() / 255 image = cv2.add(image1 * (1 - weight), red * (weight)) cv2.imwrite(path_output + filename1, image) return # ---------------------------------------------------------------------------------------------------------------------
def example_calibrate_folder(folder_in, folder_out,marker_length_mm = 3.75, marker_space_mm = 0.5,dct = aruco.DICT_6X6_1000): tools_IO.remove_files(folder_out) num_cols, num_rows = 4, 5 board = aruco.GridBoard_create(num_cols, num_rows, marker_length_mm, marker_space_mm,aruco.getPredefinedDictionary(dct)) filenames = numpy.unique(tools_IO.get_filenames(folder_in, '*.jpg,*.png'))[:3] counter, corners_list, id_list, first = [], [], [], True for filename_in in filenames: base_name, ext = filename_in.split('/')[-1].split('.')[0], filename_in.split('/')[-1].split('.')[1] image = cv2.imread(folder_in + filename_in) img_gray = cv2.cvtColor(image,cv2.COLOR_RGB2GRAY) corners, ids, rejectedImgPoints = aruco.detectMarkers(img_gray, aruco.getPredefinedDictionary(dct)) if first == True: corners_list = corners id_list = ids first = False else: corners_list = numpy.vstack((corners_list, corners)) id_list = numpy.vstack((id_list,ids)) counter.append(len(ids)) image_temp = tools_image.desaturate(image.copy()) aruco.drawDetectedMarkers(image_temp, corners) cv2.imwrite(folder_out+base_name+'.png',image_temp) print(base_name) counter = numpy.array(counter) ret, camera_matrix, dist, rvecs, tvecs = aruco.calibrateCameraAruco(corners_list, id_list, counter, board, img_gray.shape, None, None ) print(camera_matrix) return
def process_folder_extract_landmarks(self,folder_in, folder_out, write_images=True, write_annotation=True, delim='\t'): tools_IO.remove_files(folder_out, create=True) local_filenames = tools_IO.get_filenames(folder_in, '*.jpg') if write_annotation: myfile = open(folder_out+"Landmarks.txt", "w") myfile.close() for local_filename in local_filenames: image = cv2.imread(folder_in + local_filename) L_actor = self.D.get_landmarks(image) if write_images: del_triangles_A = Delaunay(L_actor).vertices result = self.D.draw_landmarks_v2(image, L_actor, color=(0, 192, 255),del_triangles=del_triangles_A) cv2.imwrite(folder_out + local_filename, result) if write_annotation: myfile = open(folder_out + "Landmarks.txt", "a") data = numpy.vstack((numpy.array([local_filename, local_filename]),(L_actor).astype(numpy.chararray))).T numpy.savetxt(myfile,data.astype(numpy.str),fmt='%s',encoding='str',delimiter=delim) myfile.close() print(local_filename) return
def example_homography_video(filename_target, folder_in, folder_out): tools_IO.remove_files(folder_out, create=True) im_target = cv2.imread(filename_target) p_target = numpy.array([[62, 48], [225, 48], [225, 93], [62, 93]]) mask = numpy.where(im_target == (0, 0, 255)) filenames = tools_IO.get_filenames(folder_in, '*.jpg') im_source = cv2.imread(folder_in + filenames[0]) pad = 0 p_source = numpy.array( [[0 + pad, 0 + pad], [im_source.shape[1] - pad, pad], [im_source.shape[1] - pad, im_source.shape[0] - pad], [pad, im_source.shape[0] - pad]], dtype=numpy.float) for filename_in in filenames: im_source = cv2.imread(folder_in + filename_in) homography2, status = tools_pr_geom.fit_homography( p_source.reshape((-1, 1, 2)), p_target.reshape((-1, 1, 2))) image_trans = cv2.warpPerspective( im_source, homography2, (im_target.shape[1], im_target.shape[0])) image_trans2 = numpy.zeros_like(image_trans) image_trans2[mask] = image_trans[mask] result = tools_image.put_layer_on_image(im_target, image_trans2, background_color=(0, 0, 0)) cv2.imwrite(folder_out + filename_in, result) return
def get_images(folder_in, H, W): images = [] for filename in tools_IO.get_filenames(folder_in, '*.jpg'): image = cv2.imread(folder_in + filename) image = tools_image.smart_resize(image, H, W) images.append(image) return numpy.array(images)
def process_folder_images(folder_in, folder_out): #tools_IO.remove_files(folder_out,create=True) filenames = tools_IO.get_filenames(folder_in, '*.jpg') for filename in filenames[:1]: P.process_file_granules(folder_in + filename, do_debug=True) return
def generate_features(self, path_input, path_output, limit=1000000, mask='*.png,*.jpg'): if not os.path.exists(path_output): os.makedirs(path_output) dict_last_layers, dict_bottlenects = self.__last_full_layers4() outputs = [ self.model.layers[len(self.model.layers) + i].output for i in dict_bottlenects.values() ] patterns = numpy.sort( numpy.array([ f.path[len(path_input):] for f in os.scandir(path_input) if f.is_dir() ])) for each in patterns: print(each) local_filenames = tools_IO.get_filenames(path_input + each, mask)[:limit] feature_filename = path_output + '/' + each + '_' + self.name + '.txt' features, filenames = [], [] if not os.path.isfile(feature_filename): bar = progressbar.ProgressBar(max_value=len(local_filenames)) for b, local_filename in enumerate(local_filenames): bar.update(b) image = cv2.imread(path_input + each + '/' + local_filename) if image is None: continue image_resized = tools_image.smart_resize( image, self.input_image_size[0], self.input_image_size[1]) image_resized = numpy.expand_dims(image_resized / 255.0, axis=0) bottlenecks = Model(self.model.input, outputs).predict(image_resized) feature = numpy.hstack( (bottlenecks[0].flatten(), bottlenecks[1].flatten())) features.append(feature[0]) filenames.append(local_filename) features = numpy.array(features) mat = numpy.zeros((features.shape[0], features.shape[1] + 1)).astype(numpy.str) mat[:, 0] = filenames mat[:, 1:] = features tools_IO.save_mat(mat, feature_filename, fmt='%s', delim='\t') return
def get_data_train(self, folder_in): local_filenames_data = tools_IO.get_filenames(folder_in,'*.jpg') local_filenames_mask = tools_IO.get_filenames(folder_in,'*.png') X_train, Y_train = [],[] for file_data,file_mask in zip (local_filenames_data,local_filenames_mask): image_data = cv2.imread(folder_in+file_data) image_mask = cv2.imread(folder_in + file_mask) image_data,image_mask = self.do_resize(image_data,image_mask) X_train.append(image_data) Y_train.append(numpy.array([image_mask[:,:,0]])/255) X_train = numpy.array(X_train) Y_train = numpy.array(Y_train) return X_train, Y_train
def stage_data(self, folder_out): filenames = tools_IO.get_filenames(folder_out, 'screenshot*.png') ids = [(f.split('.')[0]).split('_')[1] for f in filenames] if len(ids) > 0: i = 1 + numpy.array(ids, dtype=int).max() else: i = 0 cv2.imwrite(folder_out + 'screenshot_%03d.png' % i, self.get_image(do_debug=True)) return
def generate_features(self, path_input, path_output, limit=1000000, mask='*.png,*.jpg'): init = tf.global_variables_initializer() sess = tf.Session() sess.run(init) if not os.path.exists(path_output): os.makedirs(path_output) #else: #tools_IO.remove_files(path_output) patterns = numpy.sort( numpy.array([ f.path[len(path_input):] for f in os.scandir(path_input) if f.is_dir() ])) for each in patterns: print(each) local_filenames = tools_IO.get_filenames(path_input + each, mask)[:limit] feature_filename = path_output + '/' + each + '_' + self.name + '.txt' features, filenames = [], [] if not os.path.isfile(feature_filename): bar = progressbar.ProgressBar(max_value=len(local_filenames)) for b, local_filename in enumerate(local_filenames): bar.update(b) image = cv2.imread(path_input + each + '/' + local_filename) if image is None: continue image = cv2.resize( image, (self.input_shape[0], self.input_shape[1])) feature = sess.run(self.fc7, feed_dict={self.x: [image]}) features.append(feature[0]) filenames.append(local_filename) features = numpy.array(features) mat = numpy.zeros((features.shape[0], features.shape[1] + 1)).astype(numpy.str) mat[:, 0] = filenames mat[:, 1:] = features tools_IO.save_mat(mat, feature_filename, fmt='%s', delim='\t') sess.close() return
def generate_features(self, path_input, path_output, mask='*.png', limit=1000000): if not os.path.exists(path_output): os.makedirs(path_output) else: tools_IO.remove_files(path_output) tools_IO.remove_folders(path_output) patterns = numpy.sort( numpy.array([ f.path[len(path_input):] for f in os.scandir(path_input) if f.is_dir() ])) for each in patterns: print(each) local_filenames = tools_IO.get_filenames(path_input + each, mask)[:limit] feature_filename = path_output + '/' + each + '_' + self.name + '.txt' features, filenames = [], [] if not os.path.isfile(feature_filename): bar = progressbar.ProgressBar(max_value=len(local_filenames)) for b, local_filename in enumerate(local_filenames): bar.update(b) img = cv2.imread(path_input + each + '/' + local_filename) if img is None: continue img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) img = cv2.resize(img, self.input_shape).astype(numpy.float32) model = Model(inputs=self.model.input, outputs=self.model.get_layer( 'global_average_pooling2d_1').output) feature = model.predict( preprocess_input(numpy.array([img])))[0] features.append(feature) filenames.append(local_filename) features = numpy.array(features) mat = numpy.zeros((features.shape[0], features.shape[1] + 1)).astype(numpy.str) mat[:, 0] = filenames mat[:, 1:] = features tools_IO.save_mat(mat, feature_filename, fmt='%s', delim='\t') return
def stage_faces_from_cam(folder_out): filenames = tools_IO.get_filenames(folder_out,'*.jpg') if len(filenames)>0: filenames.sort() idx = int(filenames[-1].split('.')[0]) else: idx =0 r1, r2 = 0,0 use_camera = True cnt, start_time, fps = 0, time.time(), 0 cap = cv2.VideoCapture(0) cap.set(3, camera_W) cap.set(4, camera_H) while (True): if use_camera: ret, image = cap.read() L = D.get_landmarks(image) if D.are_landmarks_valid(L): result = D.cut_face(image, L, target_W=camera_W, target_H=camera_H) L = D.get_landmarks(result) if D.are_landmarks_valid(L): rotv, tvecs = D.get_pose(image,L) rotv = rotv.reshape(3, 1) tvecs = tvecs.reshape(3, 1) rotMat, jacobian = cv2.Rodrigues(rotv) r1,r2,r3= tools_calibrate.rotationMatrixToEulerAngles(rotMat) cv2.imwrite(folder_out+'%06d_%1.2d_%1.2f.jpg'%(idx,r1,r2),result) idx = idx + 1 else: result = image.copy() if time.time() > start_time: fps = cnt / (time.time() - start_time) result = cv2.putText(result, '{0: 1.1f} {1}'.format(fps, ' fps'), (0, 15), cv2.FONT_HERSHEY_SIMPLEX, 0.4,(0, 0, 0), 1, cv2.LINE_AA) result = cv2.putText(result, '{0: 1.2f} {1: 1.2f}'.format(r1,r2), (0, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4,(0, 0, 0), 1, cv2.LINE_AA) cv2.imshow('frame', result) cnt+= 1 key = cv2.waitKey(1) if key & 0xFF == 27:break cap.release() cv2.destroyAllWindows() return
def merge_all_folders(list_of_folders, folder_out, target_W, target_H, filename_watermark=None): if filename_watermark is not None: image_watermark = cv2.imread(filename_watermark) w = int(target_W / 5) h = int(w * image_watermark.shape[0] / image_watermark.shape[1]) image_watermark = cv2.resize(image_watermark, (w, h)) else: image_watermark = None tools_IO.remove_files(folder_out, create=True) pad = 0 bg_color = (255, 255, 255) empty = numpy.full((target_H, target_W, 3), numpy.array(bg_color, dtype=numpy.uint8), dtype=numpy.uint8) cnt = 0 for folder_in in list_of_folders: for filename_in in tools_IO.get_filenames(folder_in, '*.jpg,*.png'): base_name, ext = filename_in.split('/')[-1].split( '.')[0], filename_in.split('/')[-1].split('.')[1] image = cv2.imread(folder_in + filename_in) image = tools_image.smart_resize(image, target_H - 2 * pad, target_W - 2 * pad, bg_color=bg_color) result = tools_image.put_image(empty, image, pad, pad) if filename_watermark is not None: result = tools_image.put_image( result, image_watermark, 0, result.shape[1] - image_watermark.shape[1]) cv2.imwrite(folder_out + 'res_%06d_' % cnt + base_name + '.png', result) cnt += 1 print(base_name) return # ---------------------------------------------------------------------------------------------------------------------
def generate_features(self, path_input, path_output, limit=1000000, mask='*.png,*.jpg'): if not os.path.exists(path_output): os.makedirs(path_output) patterns = numpy.sort( numpy.array([ f.path[len(path_input):] for f in os.scandir(path_input) if f.is_dir() ])) for each in patterns: print(each) local_filenames = tools_IO.get_filenames(path_input + each, mask)[:limit] feature_filename = path_output + '/' + each + '_' + self.name + '.txt' features, filenames = [], [] if not os.path.isfile(feature_filename): bar = progressbar.ProgressBar(max_value=len(local_filenames)) for b, local_filename in enumerate(local_filenames): bar.update(b) image = cv2.imread(path_input + each + '/' + local_filename) if image is None: continue pre_whitened = preprocess(cv2.resize(image, (160, 160))) feature = self.__inference([pre_whitened], self.sess) features.append(feature[0]) filenames.append(local_filename) features = numpy.array(features) mat = numpy.zeros((features.shape[0], features.shape[1] + 1)).astype(numpy.str) mat[:, 0] = filenames mat[:, 1:] = features tools_IO.save_mat(mat, feature_filename, fmt='%s', delim='\t') return # ---------------------------------------------------------------------------------------------------------------------
def stage_playground(folder_out,W,H,mat_projection,mat_view,mat_model,mat_trns): M = pyrr.matrix44.multiply(mat_view.T, pyrr.matrix44.multiply(mat_model.T, mat_trns.T)) rvec, tvec = tools_pr_geom.decompose_to_rvec_tvec(M) aperture = 0.5 * (1 - mat_projection[2][0]) camera_matrix = tools_pr_geom.compose_projection_mat_3x3(W, H, aperture, aperture) H = tools_pr_geom.RT_to_H(rvec, tvec, camera_matrix) empty = numpy.full((R.H, R.W, 3), 32, dtype=numpy.uint8) result = tools_render_CV.draw_points_numpy_MVP(R.object.coord_vert, empty, R.mat_projection,R.mat_view, R.mat_model, R.mat_trns) ids = [(f.split('.')[0]).split('_')[1] for f in tools_IO.get_filenames(folder_out, 'screenshot*.png')] i = 0 if len(ids) > 0: i = 1 + numpy.array(ids, dtype=int).max() cv2.imwrite(folder_out + 'screenshot_%03d.png' % i, result) return
def process_folder(self, path_input, path_out, list_of_masks='*.png,*.jpg', limit=1000000): tools_IO.remove_files(path_out, create=True) start_time = time.time() local_filenames = tools_IO.get_filenames(path_input, list_of_masks)[:limit] local_filenames = numpy.sort(local_filenames) for local_filename in local_filenames: self.process_file(path_input + local_filename, path_out + local_filename) total_time = (time.time() - start_time) print('Processing: %s sec in total - %f per image' % (total_time, int(total_time) / len(local_filenames))) return
def __init__(self, folder_in): self.scale = 1.0 self.draw_labels = False self.folder_in = folder_in self.textcolor = (0, 0, 0) self.memorized = [] self.display_primitives = 'L' self.w = 2 self.image_small = None self.temp_line = numpy.zeros(4, dtype=numpy.int) self.filenames = tools_IO.get_filenames(self.folder_in, '*.jpg,*.png') self.filenames = numpy.unique(self.filenames) self.dict_filenames = {x: i for i, x in enumerate(self.filenames)} self.current_frame_ID = 0 self.image_to_display = None self.current_markup_ID = 0 self.last_insert_size = 1 self.Lines = None self.Boxes = None if self.display_primitives == 'L': self.Lines = Lines() self.Lines.read_from_file(self.folder_in + 'lines.txt', self.dict_filenames) self.class_names_lines = self.init_class_names_lines() self.colors_lines = tools_draw_numpy.get_colors(len( self.class_names_lines), shuffle=True) if self.display_primitives == 'B': self.Boxes = Players(self.folder_in + 'boxes.txt', self.dict_filenames) self.class_names_boxes = self.init_class_names_boxes() self.colors_boxes = tools_draw_numpy.get_colors( len(self.class_names_boxes)) self.refresh_image() return
def lm_process(folder_in, folder_out): filenames = numpy.array(tools_IO.get_filenames(folder_in, '*.jpg,*.png')) tools_IO.remove_files(folder_out, create=True) clr = (255 * numpy.array(R.bg_color[:3])).astype(numpy.int) D = detector_landmarks.detector_landmarks( '..//_weights//shape_predictor_68_face_landmarks.dat', filename_markers1) L_prev = None for filename_in in filenames: time_start = time.time() base_name, ext = filename_in.split('/')[-1].split( '.')[0], filename_in.split('/')[-1].split('.')[1] image = cv2.imread(folder_in + filename_in) gray = tools_image.desaturate(image) L = D.get_landmarks(image) #if not numpy.all(L==0):L_prev = L.copy() #else:L = L_prev.copy() rvec, tvec = D.get_pose_perspective(image, L, D.model_68_points, R.mat_trns) image_3d = R.get_image_perspective(rvec, tvec, lookback=True, scale=(1, 2, 1)) #RT = tools_pr_geom.compose_RT_mat(rvec, tvec,do_rodriges=True) #image_3d = R.get_image_perspective_M(RT, lookback=True, scale=(1, 2, 1)) #image_3d = cv2.flip(image_3d,1) #gray = cv2.imread('D:\LM\out11/'+base_name+'.jpg') #gray = tools_image.do_resize(gray,(image_3d.shape[1],image_3d.shape[0])) result = D.draw_landmarks_v2(gray, L, color=(0, 0, 200), w=4) #result = D.draw_annotation_box(result, rvec, tvec, color=(0, 128, 255), w=3) #result = tools_image.blend_avg(gray, image_3d, clr, weight=0.25) cv2.imwrite(folder_out + base_name + '.png', result) print('%s : %1.2f sec' % (base_name, (time.time() - time_start))) return
def get_proj_dist_mat_for_images(folder_in,chess_rows,chess_cols,cell_size=1,folder_out=None): x, y = numpy.meshgrid(range(chess_rows), range(chess_cols)) world_points = numpy.hstack((x.reshape(chess_rows*chess_cols, 1), y.reshape(chess_rows*chess_cols, 1), numpy.zeros((chess_rows*chess_cols, 1)))).astype(numpy.float32) _3d_points = [] _2d_points = [] for local_filename in tools_IO.get_filenames(folder_in,'*.png,*.jpg'): image = cv2.imread(folder_in+local_filename) #image = tools_image.do_rescale(image, 0.5) gray = tools_image.desaturate(image) ret, corners = cv2.findChessboardCorners(cv2.cvtColor(image, cv2.COLOR_BGR2GRAY), (chess_rows, chess_cols),cv2.CALIB_CB_ADAPTIVE_THRESH) if ret: corners = cv2.cornerSubPix(cv2.cvtColor(image, cv2.COLOR_BGR2GRAY), corners, (11, 11), (-1, -1),(cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)) _2d_points.append(corners) _3d_points.append(world_points) corners = corners.reshape(-1, 2) for i in range(0,corners.shape[0]):gray = tools_draw_numpy.draw_circle(gray, corners[i, 1], corners[i, 0], 3, [0, 0, 255], alpha_transp=0) print(local_filename,len(corners)) if folder_out!=None: cv2.imwrite(folder_out + local_filename, gray) #camera_matrix = numpy.array([[im.shape[1], 0, im.shape[0]], [0, im.shape[0], im.shape[1]], [0, 0, 1]]).astype(numpy.float64) #dist=numpy.zeros((1,5)) flag = cv2.CALIB_USE_INTRINSIC_GUESS + cv2.CALIB_ZERO_TANGENT_DIST + cv2.CALIB_RATIONAL_MODEL matrix_init = numpy.zeros((3, 3), numpy.float32) matrix_init[0][0] = image.shape[1] matrix_init[1][1] = image.shape[0] matrix_init[0][2] = matrix_init[0][0]/2 matrix_init[1][2] = matrix_init[1][1]/2 matrix_init[2][2] = 1.0 dist_init = numpy.zeros((1, 4), numpy.float32) ret, camera_matrix, dist, rvecs, tvecs = cv2.calibrateCamera(1.0 * numpy.array(_3d_points), _2d_points,(image.shape[1], image.shape[0]), matrix_init,dist_init, flags=flag) print(camera_matrix) ret, camera_matrix, dist, rvecs, tvecs = cv2.calibrateCamera(cell_size*numpy.array(_3d_points), _2d_points, (image.shape[1], image.shape[0]), matrix_init, dist_init,flags=flag) return camera_matrix,dist,rvecs, tvecs
def folder_to_video(folder_in, filename_out, mask='*.jpg', framerate=24, resize_W=None, resize_H=None, do_reverce=False, silent=False): fileslist = tools_IO.get_filenames(folder_in, mask) fileslist.sort() if resize_W is None or resize_H is None: image = cv2.imread(os.path.join(folder_in, fileslist[0])) resize_H, resize_W = image.shape[:2] fourcc = cv2.VideoWriter_fourcc(*'mp4v') out = cv2.VideoWriter(filename_out, fourcc, framerate, (resize_W, resize_H)) if not silent: bar = progressbar.ProgressBar(len(fileslist)) bar.start() for b, filename in enumerate(fileslist): if not silent: bar.update(b) image = cv2.imread(os.path.join(folder_in, filename)) if resize_W is not None and resize_H is not None: image = cv2.resize(image, (resize_W, resize_H), interpolation=cv2.INTER_CUBIC) out.write(image) if do_reverce: for filename in reversed(fileslist): image = cv2.imread(os.path.join(folder_in, filename)) if resize_W is not None and resize_H is not None: image = cv2.resize(image, (resize_W, resize_H), interpolation=cv2.INTER_CUBIC) out.write(image) out.release() cv2.destroyAllWindows()
def process_folder_negatives(self, path_input, path_out, list_of_masks='*.png,*.jpg', limit=1000000, confidence=0.80): tools_IO.remove_files(path_out) local_filenames = tools_IO.get_filenames(path_input, list_of_masks)[:limit] local_filenames = numpy.sort(local_filenames) for local_filename in local_filenames: image = cv2.imread(path_input + local_filename) if image is None: return [] boxes_yxyx, classes, scores = self.process_image(image) if len(scores) > 0 and scores[0] >= confidence: filename_out = path_out + '%02d_' % int( 100 * scores[0]) + local_filename tools_YOLO.draw_and_save(filename_out, image, boxes_yxyx, scores, classes, self.colors, self.class_names) return
def folder_to_animated_gif_imageio(path_input, filename_out, mask='*.png', framerate=10, resize_H=64, resize_W=64, do_reverce=False): tools_IO.remove_file(filename_out) images = [] filenames = tools_IO.get_filenames(path_input, mask) bar = progressbar.ProgressBar(max_value=len(filenames)) bar.start() for b, filename_in in enumerate(filenames): bar.update(b) image = cv2.imread(path_input + filename_in) image = tools_image.do_resize(image, (resize_W, resize_H)) image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) images.append(image) images = numpy.array(images, dtype=numpy.uint8) if not do_reverce: imageio.mimsave(filename_out, images, 'GIF', duration=1 / framerate) else: images_all = [] for image in images: images_all.append(image) for image in reversed(images): images_all.append(image) images_all = numpy.array(images_all, dtype=images.dtype) imageio.mimsave(filename_out, images_all, 'GIF', duration=1 / framerate) return
def process_folder_faceswap(self,filename_clbrt,folder_in, folder_out): tools_IO.remove_files(folder_out, create=True) local_filenames = tools_IO.get_filenames(folder_in, '*.jpg') image_clbrt = cv2.imread(filename_clbrt) L_clbrt = self.D.get_landmarks(image_clbrt) del_triangles_C = Delaunay(L_clbrt).vertices R_c = tools_GL.render_GL(image_clbrt) image_actor = cv2.imread(folder_in + local_filenames[0]) R_a = tools_GL.render_GL(image_actor) for local_filename in local_filenames: image_actor = cv2.imread(folder_in + local_filename) L_actor = self.D.get_landmarks(image_actor) R_a.update_texture(image_actor) result = self.do_faceswap(R_c, R_a, image_clbrt, image_actor, L_clbrt, L_actor, del_triangles_C) cv2.imwrite(folder_out + local_filename, result) print(local_filename) return
def process_folder(self, path_input, path_out, list_of_masks='*.png,*.jpg', limit=1000000, markup_only=False): tools_IO.remove_files(path_out) start_time = time.time() local_filenames = tools_IO.get_filenames(path_input, list_of_masks)[:limit] result = [('filename', 'x_left', 'y_top', 'x_right', 'y_bottom', 'class_ID', 'confidence')] local_filenames = numpy.sort(local_filenames) for local_filename in local_filenames: filename_out = path_out + local_filename if not markup_only else None for each in self.process_file(path_input + local_filename, filename_out): result.append(each) tools_IO.save_mat(result, path_out + 'markup_res.txt', delim=' ') total_time = (time.time() - start_time) print('Processing: %s sec in total - %f per image' % (total_time, int(total_time) / len(local_filenames))) return
process_key(key) if key & 0xFF == 27: break if use_camera: cap.release() cv2.destroyAllWindows() return # --------------------------------------------------------------------------------------------------------------------- if __name__ == '__main__': folder_in = './images/ex_faceswap/01/' folder_out = './images/output1/' list_filenames = tools_IO.get_filenames(folder_in, '*.jpg') filename_clbrt, filename_actor = list_filenames[-1], list_filenames[1] #filename_clbrt = folder_in+'Person5c.jpg' #filename_actor = folder_in+'Person2a.jpg' image_clbrt = cv2.imread(folder_in + filename_clbrt) image_actor = cv2.imread(folder_in + filename_actor) FS = tools_faceswap.Face_Swaper(D, image_clbrt, image_actor, device='cpu', adjust_every_frame=True, do_narrow_face=True) demo_live(FS)