def align_two_images_homography(img1, img2,detector='SIFT',matchtype='knn'): img1_gray_rgb = tools_image.desaturate(img1) img2_gray_rgb = tools_image.desaturate(img2) points1, des1 = tools_alg_match.get_keypoints_desc(img1, detector) points2, des2 = tools_alg_match.get_keypoints_desc(img2, detector) match1, match2, distance = tools_alg_match.get_matches_from_keypoints_desc(points1, des1, points2, des2, matchtype) homography= None if match1.size != 0: homography= get_homography_by_keypoints_desc(points1, des1, points2, des2, matchtype) if homography is None: return img1,img2 else: return img1, img2 for each in match1: cv2.circle(img1_gray_rgb, (int(each[0]), int(each[1])), 3, [0, 0, 255],thickness=-1) for each in match2: cv2.circle(img2_gray_rgb, (int(each[0]), int(each[1])), 3, [255, 255, 0], thickness=-1) result_image1, result_image2 = get_stitched_images_using_homography(img2_gray_rgb, img1_gray_rgb, homography, borderMode=cv2.BORDER_REPLICATE,background_color=(255, 255, 255)) q = cv2.matchTemplate(result_image1, result_image2, method=cv2.TM_CCOEFF_NORMED)[0, 0] q = int((1 + q) * 128) return result_image1,result_image2, q
def demo_stereo_05_matchTemplate(): folder_input = 'images/ex_stereo/' folder_output = 'images/output/' filenameL = '1L.png' filenameR = '1R.png' disp_v1, disp_v2, disp_h1, disp_h2 = -2, +2, -70, -10 if not os.path.exists(folder_output): os.makedirs(folder_output) else: tools_IO.remove_files(folder_output) imgL = cv2.imread(folder_input + filenameL) imgR = cv2.imread(folder_input + filenameR) imgL_gray_rgb = tools_image.desaturate(imgL) imgR_gray_rgb = tools_image.desaturate(imgR) coord1, coord2, quality = tools_alg_match.get_best_matches(imgL, imgR, disp_v1, disp_v2, disp_h1, disp_h2, window_size=15, step=5) dispL, dispR = tools_alg_match.get_disparity_from_matches( imgL.shape[0], imgL.shape[1], coord1, coord2, disp_v1, disp_v2, disp_h1, disp_h2) cv2.imwrite(folder_output + 'L_disp.png', dispL) cv2.imwrite(folder_output + 'R_disp.png', dispR) return
def example_01_lines_ski(filename_in, folder_out): angle_bound1 = 30 angle_bound2 =-30 image = cv2.imread(filename_in) H,W = image.shape[:2] #skeleton = cv2.Canny(image, 20, 80) skeleton = Ske.binarized_to_skeleton_ski(Ske.binarize(image)) lines_vert, weights_vert = Hough.get_lines_ski(skeleton, max_count=5, min_weight=50,the_range=Hough.get_angle_range(angle_bound1, 20, 1)) lines_horz, weights_horz = Hough.get_lines_ski(skeleton, max_count=5, min_weight=50,the_range =Hough.get_angle_range(angle_bound2,20, 1)) lines_vert = numpy.array([tools_render_CV.line_box_intersection(line, (0, 0, W - 1, H - 1)) for line in lines_vert]) lines_horz = numpy.array([tools_render_CV.line_box_intersection(line, (0, 0, W - 1, H - 1)) for line in lines_horz]) image_lines = 1 * tools_image.desaturate(image.copy()) image_lines = draw_lines(image_lines, lines_horz, color=(0, 128, 255), w=4) image_lines = draw_lines(image_lines, lines_vert, color=(0, 0, 255), w=4) alpha = 0.5 gray3d = tools_image.desaturate(image) result = alpha * image_lines + (1 - alpha) * gray3d cv2.imwrite(folder_out + 'skeleton.png', skeleton) cv2.imwrite(folder_out + 'lines.png', result) return
def analyze_matches(folder_in, filename_in, folder_out, disp_v1, disp_v2, disp_h1, disp_h2, window_size=5, step=10): #if not os.path.exists(folder_out): # os.makedirs(folder_out) #else: # tools_IO.remove_files(folder_out) image1 = cv2.imread(folder_in + filename_in) pattern_width = 200 print('Calculating matches ...') start_time = time.time() coord1, coord2, quality = tools_alg_match.get_best_matches( image1, image1, disp_v1, disp_v2, disp_h1, disp_h2, window_size, step) print('%s sec\n\n' % (time.time() - start_time)) quality_image1 = tools_alg_match.interpolate_image_by_matches( image1.shape[0], image1.shape[1], coord2, quality) cv2.imwrite(folder_out + '%d-Q1.png' % window_size, quality_image1) quality_image2 = tools_alg_match.interpolate_image_by_matches( image1.shape[0], image1.shape[1], coord1, quality) cv2.imwrite(folder_out + '%d-Q2.png' % window_size, quality_image2) idx = numpy.where(quality >= 240) coord1, coord2 = coord1[idx], coord2[idx] idx = numpy.random.choice(coord1.shape[0], int(coord1.shape[0] * 0.3)) gray1_rgb = tools_image.desaturate(image1) gray2_rgb = tools_image.desaturate(image1) gray1_rgb, gray2_rgb = tools_alg_match.visualize_matches_coord( coord1[idx, :], coord2[idx, :], gray1_rgb, gray2_rgb) cv2.imwrite(folder_out + '%d-points1.png' % window_size, gray1_rgb) cv2.imwrite(folder_out + '%d-points2.png' % window_size, gray2_rgb) blend1 = blend_by_coord(image1, coord1, coord2, window_size, fill_declines=False, background_color=(128, 128, 128)) blend2 = blend_by_coord(image1, coord2, coord1, window_size, fill_declines=False, background_color=(128, 128, 128)) cv2.imwrite(folder_out + '%d-blend1.png' % window_size, blend1) cv2.imwrite(folder_out + '%d-blend2.png' % window_size, blend2) return
def example_find_matches_for_homography(detector='SIFT', matchtype='knn'): folder_input = './images/ex_keypoints/' img1 = cv2.imread(folder_input + 'left.jpg') img2 = cv2.imread(folder_input + 'rght.jpg') img1_gray_rgb = tools_image.desaturate(img1) img2_gray_rgb = tools_image.desaturate(img2) folder_output = './images/output/' if not os.path.exists(folder_output): os.makedirs(folder_output) #else: # tools_IO.remove_files(folder_output) points1, des1 = tools_alg_match.get_keypoints_desc(img1, detector) points2, des2 = tools_alg_match.get_keypoints_desc(img2, detector) match1, match2, distance = tools_alg_match.get_matches_from_keypoints_desc(points1, des1, points2, des2, matchtype) homography = tools_calibrate.get_homography_by_keypoints_desc(points1, des1, points2, des2, matchtype) if homography is None: return match2_cand = cv2.perspectiveTransform(match1.reshape(-1, 1, 2).astype(numpy.float32), homography) hit = numpy.zeros(match1.shape[0]) for i in range(0, match1.shape[0]): if numpy.linalg.norm(match2_cand[i] - match2[i]) <= 5: hit[i] = 1 img1_gray_rgb = tools_draw_numpy.draw_circle(img1_gray_rgb, int(match1[i][1]), int(match1[i][0]), 3,[32, 192, 0]) img2_gray_rgb = tools_draw_numpy.draw_circle(img2_gray_rgb, int(match2[i][1]), int(match2[i][0]), 3,[32, 192, 0]) else: img1_gray_rgb = tools_draw_numpy.draw_circle(img1_gray_rgb, int(match1[i][1]), int(match1[i][0]), 3,[0, 64, 255]) img2_gray_rgb = tools_draw_numpy.draw_circle(img2_gray_rgb, int(match2[i][1]), int(match2[i][0]), 3,[0, 64, 255]) img2_gray_rgb, img1_gray_rgb = tools_calibrate.get_stitched_images_using_homography(img2_gray_rgb, img1_gray_rgb,homography) fig = plt.figure(figsize=(12, 6)) fig.subplots_adjust(hspace=0.01) roc_auc = 0 if hit.size >= 2: fpr, tpr, thresholds = metrics.roc_curve(hit, -distance) roc_auc = auc(fpr, tpr) filename_out = folder_output + ('_ROC_%s_%s_auc_%1.3f.png' % (detector, matchtype, roc_auc)) tools_plot.plot_tp_fp(plt.subplot(1, 1, 1), fig, tpr, fpr, roc_auc) plt.savefig(filename_out) cv2.imwrite(folder_output + ('%s_%s_auc_%1.3f_left_matches.png' % (detector, matchtype, roc_auc)), img1_gray_rgb) cv2.imwrite(folder_output + ('%s_%s_auc_%1.3f_rght_matches.png' % (detector, matchtype, roc_auc)), img2_gray_rgb) return
def example_03_find_homography_by_keypoints(detector='SIFT', matchtype='knn'): folder_input = 'images/ex_keypoints/' img1 = cv2.imread(folder_input + 'left.jpg') img2 = cv2.imread(folder_input + 'rght.jpg') img1_gray_rgb = tools_image.desaturate(img1) img2_gray_rgb = tools_image.desaturate(img2) folder_output = 'images/output/' output_filename1 = folder_output + 'left_transformed_homography.png' output_filename2 = folder_output + 'rght_transformed_homography.png' output_filename = folder_output + 'blended_homography.png' if not os.path.exists(folder_output): os.makedirs(folder_output) else: tools_IO.remove_files(folder_output) points1, des1 = tools_alg_match.get_keypoints_desc(img1, detector) points2, des2 = tools_alg_match.get_keypoints_desc(img2, detector) homography = tools_calibrate.get_homography_by_keypoints_desc( points1, des1, points2, des2, matchtype) match1, match2, distance = tools_alg_match.get_matches_from_keypoints_desc( points1, des1, points2, des2, matchtype) for each in match1: img1_gray_rgb = tools_draw_numpy.draw_circle(img1_gray_rgb, int(each[1]), int(each[0]), 3, [0, 0, 255]) for each in match2: img2_gray_rgb = tools_draw_numpy.draw_circle(img2_gray_rgb, int(each[1]), int(each[0]), 3, [255, 255, 0]) result_image1, result_image2 = tools_calibrate.get_stitched_images_using_homography( img1_gray_rgb, img2_gray_rgb, homography, background_color=(255, 255, 255)) result_image = tools_image.blend_avg(result_image1, result_image2, background_color=(255, 255, 255)) # result_image = tools_calibrate.blend_multi_band(result_image1, result_image2) cv2.imwrite(output_filename1, result_image1) cv2.imwrite(output_filename2, result_image2) cv2.imwrite(output_filename, result_image) return
def demo_stereo_03_keypoints(): folder_input = 'images/ex_stereo/' folder_output = 'images/output/' filenameL = '1L.png' filenameR = '1R.png' disp_v1, disp_v2, disp_h1, disp_h2 = 0, 1, -70, -10 if not os.path.exists(folder_output): os.makedirs(folder_output) else: tools_IO.remove_files(folder_output) imgL = cv2.imread(folder_input + filenameL) imgR = cv2.imread(folder_input + filenameR) imgL_gray_rgb = tools_image.desaturate(imgL) imgR_gray_rgb = tools_image.desaturate(imgR) points1, des1 = tools_alg_match.get_keypoints_desc(imgL) points2, des2 = tools_alg_match.get_keypoints_desc(imgR) match1, match2, distance = tools_alg_match.get_matches_from_keypoints_desc( points1, des1, points2, des2) idx = [] for i in range(0, match1.shape[0]): row1, col1 = match1[i, 1], match1[i, 0] row2, col2 = match2[i, 1], match2[i, 0] if (col2 - col1 >= disp_h1) and (col2 - col1 < disp_h2) and ( row2 - row1 >= disp_v1) and (row2 - row1 < disp_v2): idx.append(i) match1, match2, distance = match1[idx], match2[idx], distance[idx] for i in range(0, match1.shape[0]): r = int(255 * numpy.random.rand()) color = cv2.cvtColor( numpy.array([r, 255, 225], dtype=numpy.uint8).reshape(1, 1, 3), cv2.COLOR_HSV2BGR) imgL_gray_rgb = tools_draw_numpy.draw_circle(imgL_gray_rgb, match1[i, 1], match1[i, 0], 4, color) imgR_gray_rgb = tools_draw_numpy.draw_circle(imgR_gray_rgb, match2[i, 1], match2[i, 0], 4, color) cv2.imwrite(folder_output + 'matches03_L.png', imgL_gray_rgb) cv2.imwrite(folder_output + 'matches03_R.png', imgR_gray_rgb) return
def process_file_debug(self, filename_in, folder_out): image = cv2.imread(filename_in) 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) u_boxes, u_scores, u_classes = detector_YOLO3_core.get_tensors_box_score_class_unfilter( self.model.output, self.anchors, self.anchor_mask, len(self.class_names), self.input_tensor_shape, score_threshold=0.01, iou_threshold=self.nms_threshold) boxes_yxyx, classes, scores = self.sess.run( [u_boxes, u_classes, u_scores], feed_dict={ self.model.input: image_resized, self.input_tensor_shape: [image.shape[0], image.shape[1]], K.learning_phase(): 0 }) self.process_file(filename_in, folder_out + filename_in.split('/')[-1]) total_image = tools_image.desaturate(image) for c in list(set(classes)): idx = numpy.where(classes == c) temp_image = tools_YOLO.draw_classes_on_image( tools_image.desaturate(image), boxes_yxyx[idx], [1] * len(idx[0]), self.colors[c], draw_score=False) total_image = tools_YOLO.draw_classes_on_image(total_image, boxes_yxyx[idx], scores[idx], self.colors[c], draw_score=True) cv2.imwrite( folder_out + 'class_%02d-%s-p%02d.png' % (c, self.class_names[c], 100 * scores[idx].max()), temp_image) cv2.imwrite(folder_out + 'all_boxes.png', total_image) return
def get_proj_dist_mat_for_images(folder_in, chess_rows, chess_cols, 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 image_name in fnmatch.filter(listdir(folder_in), '*.jpg'): im = cv2.imread(folder_in + image_name) im_gray = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY) im_gray_RGB = tools_image.desaturate(im) ret, corners = cv2.findChessboardCorners(im_gray, (chess_rows, chess_cols)) if ret: corners = cv2.cornerSubPix(im_gray, 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]): im_gray_RGB = tools_draw_numpy.draw_circle(im_gray_RGB, corners[i, 1], corners[i, 0], 3, [0, 0, 255], alpha_transp=0) if folder_out != None: cv2.imwrite(folder_out + image_name, im_gray_RGB) 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] = im.shape[0] / 2 matrix_init[0][2] = im.shape[1] / 2 matrix_init[1][1] = matrix_init[0][0] matrix_init[1][2] = matrix_init[0][2] matrix_init[2][2] = 1.0 dist_init = numpy.zeros((1, 4), numpy.float32) ret, camera_matrix, dist, rvecs, tvecs = cv2.calibrateCamera( _3d_points, _2d_points, (im.shape[1], im.shape[0]), matrix_init, dist_init, flags=flag) return camera_matrix, dist
def draw_landmarks(self, image): gray = tools_image.desaturate(image) landmarks = self.get_landmarks(image) if len(landmarks) != 68 or numpy.sum(landmarks) == 0: return gray del_triangles = Delaunay(landmarks).vertices for landmark in landmarks: cv2.circle(gray, (int(landmark[0]), int(landmark[1])), 2, (0, 128, 255), -1) #gray=tools_draw_numpy.draw_circle(gray, landmark[1],landmark[0], 3, (0,128,255),alpha_transp=0.7) for t in del_triangles: p0 = (int(landmarks[t[0], 0]), int(landmarks[t[0], 1])) p1 = (int(landmarks[t[1], 0]), int(landmarks[t[1], 1])) p2 = (int(landmarks[t[2], 0]), int(landmarks[t[2], 1])) cv2.line(gray, p0, p1, (0, 0, 255)) cv2.line(gray, p0, p2, (0, 0, 255)) cv2.line(gray, p2, p1, (0, 0, 255)) #gray = tools_draw_numpy.draw_line(gray, p0[1], p0[0], p1[1], p1[0], (0, 0, 255), alpha_transp=0.7) #gray = tools_draw_numpy.draw_line(gray, p0[1], p0[0], p2[1], p2[0], (0, 0, 255), alpha_transp=0.7) #gray = tools_draw_numpy.draw_line(gray, p2[1], p2[0], p1[1], p1[0], (0, 0, 255), alpha_transp=0.7) return gray
def example_01(filename_in): sobel = numpy.zeros((8, 17), dtype=numpy.float32) sobel[:, sobel.shape[1] // 2:] = +1 sobel[:, :sobel.shape[1] // 2] = -1 sobel = sobel / sobel.sum() image = cv2.imread(filename_in) gray = cv2.imread(filename_in, 0) result = cv2.filter2D(gray, 0, sobel) result2 = numpy.maximum(255 - result, result) result2 = exposure.adjust_gamma(result2, 6) image_bin = Ske.binarize(result2) image_ske = Ske.binarized_to_skeleton(image_bin) segemnts = Ske.skeleton_to_segments(image_ske) colors = tools_draw_numpy.get_colors(len(segemnts), shuffle=True) image_segm = tools_draw_numpy.draw_segments(tools_image.desaturate(image), segemnts, colors, w=1) cv2.imwrite(folder_out + 'filtered.png', result) cv2.imwrite(folder_out + 'filtered2.png', result2) cv2.imwrite(folder_out + 'ske.png', image_ske) cv2.imwrite(folder_out + 'segm.png', image_segm) 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_file(self, filename_in, filename_out,draw_spline=True): if not os.path.isfile(filename_in): return [] image = cv2.imread(filename_in) image = tools_image.rgb2bgr(image) if image is None: return [] if draw_spline==False: boxes_yxyx, scores, classes = self.process_image(image) markup = tools_YOLO.get_markup(filename_in, boxes_yxyx, scores, classes) tools_YOLO.draw_and_save(filename_out, image, boxes_yxyx, scores, classes,self.colors, self.class_names) else: r = self.model.detect([image], verbose=0)[0] boxes_yxyx, scores, classes,masks = r['rois'], r['scores'], r['class_ids'],r['masks'] class_ID = tools_IO.smart_index(self.class_names,'person')[0] msk = (scores > self.obj_threshold).tolist() #msk = msk and (classes == class_ID) msk = numpy.array(msk) boxes_yxyx, scores, classes, masks = boxes_yxyx[msk], scores[msk], classes[msk], masks[:,:,msk] markup = tools_YOLO.get_markup(filename_in, boxes_yxyx, scores, classes) detector_Mask_RCNN_core.display_instances(tools_image.desaturate(image), boxes_yxyx, masks, classes, self.class_names,filename_out,scores,self.colors) return markup
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 example_board_pose_estimation(folder_input, folder_output, chess_rows, chess_cols, cameraMatrix, dist): if not os.path.exists(folder_output): os.makedirs(folder_output) else: tools_IO.remove_files(folder_output) R = 1 axis_3d_end = numpy.array([[R, 0, 0], [0, R, 0], [0, 0, -R]], dtype=numpy.float32) axis_3d_start = numpy.array([[0, 0, 0]], dtype=numpy.float32) points_3d = numpy.array( [[-1, -1, -1], [-1, +1, -1], [+1, +1, -1], [+1, -1, -1], [-1, -1, +1], [-1, +1, +1], [+1, +1, +1], [+1, -1, +1]], dtype=numpy.float32) points_3d[:, [0, 1, 2]] *= 0.5 points_3d[:, [0, 1, 2]] += 0.5 points_3d[:, [2]] *= -1 points_3d[:, [0]] += 3 points_3d[:, [1]] += 4 for image_name in fnmatch.filter(listdir(folder_input), '*.jpg'): img = cv2.imread(folder_input + image_name) image_AR = tools_image.desaturate(img) rvecs, tvecs = tools_calibrate.pose_estimation_chessboard( img, chess_rows, chess_cols, cameraMatrix, dist) if rvecs.size != 0: axis_2d_end, jac = cv2.projectPoints(axis_3d_end, rvecs, tvecs, cameraMatrix, dist) axis_2d_start, jac = cv2.projectPoints(axis_3d_start, rvecs, tvecs, cameraMatrix, dist) cv2.line(image_AR, (axis_2d_start[0, 0, 0], axis_2d_start[0, 0, 1]), (axis_2d_end[0, 0, 0], axis_2d_end[0, 0, 1]), (0, 0, 255), thickness=3) cv2.line(image_AR, (axis_2d_start[0, 0, 0], axis_2d_start[0, 0, 1]), (axis_2d_end[1, 0, 0], axis_2d_end[1, 0, 1]), (0, 255, 0), thickness=3) cv2.line(image_AR, (axis_2d_start[0, 0, 0], axis_2d_start[0, 0, 1]), (axis_2d_end[2, 0, 0], axis_2d_end[2, 0, 1]), (255, 0, 0), thickness=3) #image_AR = tools_render_CV.draw_cube_numpy(image_AR, camera_matrix, numpy.zeros(4), rvecs.flatten(), tvecs.flatten(),(0.5, 0.5, 0.5),points_3d=points_3d) image_AR = tools_render_CV.draw_compass( image_AR, camera_matrix, dist, numpy.array(rvecs).flatten(), numpy.array(tvecs).flatten(), R * 5) cv2.imwrite(folder_output + image_name, image_AR) return
def test_cascade(): image = tools_image.desaturate(cv2.imread(filename_in)) objects, rejectLevels, levelWeights = \ object_detector.detectMultiScale3(image, scaleFactor=1.05, minSize=(20, 20), outputRejectLevels=True) for (x, y, w, h) in objects:cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2) cv2.imwrite(filename_out,image) return
def draw_and_save(filename_out, image, boxes_yxyx, scores, classes, colors, class_names): if filename_out is not None: res_image = draw_objects_on_image(tools_image.desaturate(image, 1.0), boxes_yxyx, scores, classes, colors, class_names) cv2.imwrite(filename_out, res_image) return
def example_shi_tomasi_corner_detector(filename_in, filename_out, R=2): img = cv2.imread(filename_in) gray_rgb = tools_image.desaturate(img) for each in tools_alg_match.get_corners_Shi_Tomasi(img): gray_rgb = tools_draw_numpy.draw_circle(gray_rgb, each[1], each[0], R, [0, 0, 255]) cv2.imwrite(filename_out, gray_rgb) return
def demo_stereo_04_keypoints_limited(): folder_input = 'images/ex_stereo/' folder_output = 'images/output/' filenameL = '1L.png' filenameR = '1R.png' disp_v1, disp_v2, disp_h1, disp_h2 = 0, 1, -70, -10 if not os.path.exists(folder_output): os.makedirs(folder_output) else: tools_IO.remove_files(folder_output) imgL = cv2.imread(folder_input + filenameL) imgR = cv2.imread(folder_input + filenameR) imgL_gray_rgb = tools_image.desaturate(imgL) imgR_gray_rgb = tools_image.desaturate(imgR) points1, des1 = tools_alg_match.get_keypoints_desc(imgL) points2, des2 = tools_alg_match.get_keypoints_desc(imgR) match1, match2, distance = tools_alg_match.get_matches_from_desc_limit_by_disp( points1, des1, points2, des2, disp_v1, disp_v2, disp_h1, disp_h2, 'ccc') R = 4 for i in range(0, match1.shape[0]): r = int(255 * numpy.random.rand()) color = cv2.cvtColor( numpy.array([r, 255, 225], dtype=numpy.uint8).reshape(1, 1, 3), cv2.COLOR_HSV2BGR) imgL_gray_rgb = tools_draw_numpy.draw_circle(imgL_gray_rgb, match1[i, 1], match1[i, 0], R, color) imgR_gray_rgb = tools_draw_numpy.draw_circle(imgR_gray_rgb, match2[i, 1], match2[i, 0], R, color) cv2.imwrite(folder_output + 'matches03_L.png', imgL_gray_rgb) cv2.imwrite(folder_output + 'matches03_R.png', imgR_gray_rgb) return
def example_ORB(filename_in, filename_out, R=2): img = cv2.imread(filename_in) gray_rgb = tools_image.desaturate(img) points, desc = tools_alg_match.get_keypoints_desc(img, detector='ORB') for each in points: gray_rgb = tools_draw_numpy.draw_circle(gray_rgb, each[1], each[0], R, [0, 0, 255]) cv2.imwrite(filename_out, gray_rgb) return
def example_Fast_Corner_Detector(filename_in, filename_out, R=2): img = cv2.imread(filename_in) gray_rgb = tools_image.desaturate(img) points = tools_alg_match.get_corners_Fast(img) for each in points: gray_rgb = tools_draw_numpy.draw_circle(gray_rgb, each[1], each[0], R, [0, 0, 255]) cv2.imwrite(filename_out, gray_rgb) return
def segments_to_ellipse(self, image, segments, do_debug=False): self.H, self.W = image.shape[:2] weights = numpy.array([len(s) for s in segments], dtype=numpy.float) weights = weights / weights.sum() Q, E, Cands = {}, {}, {} for s1 in range(len(segments) - 1): for s2 in range(s1 + 1, len(segments)): ellipse, idx_match = self.estimate_ellipse(segments, s1, s2) if ellipse is None: continue E[(s1, s2)] = ellipse Q[(s1, s2)] = weights[idx_match].sum() Cands[(s1, s2)] = idx_match if do_debug: image_debug = tools_image.desaturate(image) image_debug = self.draw_segments(image_debug, [segments[s1]], color=(90, 0, 255), w=4) image_debug = self.draw_segments(image_debug, [segments[s2]], color=(0, 90, 255), w=4) center = (int(ellipse[0][0]), int(ellipse[0][1])) axes = (int(ellipse[1][0] / 2), int(ellipse[1][1] / 2)) rotation_angle = ellipse[2] cv2.ellipse(image_debug, center, axes, rotation_angle, startAngle=0, endAngle=360, color=(0, 0, 190), thickness=1) cv2.imwrite( self.folder_out + 'ellips_%03d_%03d.png' % (s1, s2), image_debug) ellipse, cands = None, None if len(Q) > 0: key = tools_IO.max_element_by_value(Q)[0] cands = Cands[key] #ellipse = E[key] ellipse = self.refine_ellipse(segments, cands) return ellipse, cands # ----------------------------------------------------------------------------------------------------------------
def draw_face(self,image): gray = tools_image.desaturate(image) objects = self.detector(gray) if len(objects) == 1: for face in objects: xmin = face.left() ymin = face.top() xmax = face.right() ymax = face.bottom() cv2.rectangle(image, (xmin, ymin), (xmax, ymax), (0, 255, 0), 2) return image
def detect_face(self, image): gray = tools_image.desaturate(image) objects = self.detector(gray) if len(objects) == 1: for face in objects: xmin = face.left() ymin = face.top() xmax = face.right() ymax = face.bottom() return image[ymin:ymax, xmin:xmax, :] return None
def example_segment_detection(): image = cv2.imread(filename_in) segments = F.extract_segments(image, min_size=30) image_debug = tools_image.desaturate(image.copy()) colors = tools_IO.get_colors(len(segments), shuffle=True) image_debug = F.draw_segments(image_debug, segments, colors, w=4, put_text=True) cv2.imwrite(folder_out + 'result.png', image_debug) return
def get_landmarks(self, image): res = numpy.zeros((68, 2), dtype=numpy.float) if image is None: return res gray = tools_image.desaturate(image) objects = self.detector(gray) if len(objects) == 1: landmarks = self.predictor(gray, objects[0]) res = [] for n in range(0, 68): res.append([landmarks.part(n).x, landmarks.part(n).y]) res = numpy.array(res) return res.astype(numpy.float)
def draw_landmarks_v2(self, image,landmarks,del_triangles=None,color=(0, 128, 255)): gray = tools_image.desaturate(image,level=0) for landmark in landmarks: cv2.circle(gray, (int(landmark[0]), int(landmark[1])), 2, color, -1) if del_triangles is not None: for t in del_triangles: p0 = (int(landmarks[t[0], 0]), int(landmarks[t[0], 1])) p1 = (int(landmarks[t[1], 0]), int(landmarks[t[1], 1])) p2 = (int(landmarks[t[2], 0]), int(landmarks[t[2], 1])) cv2.line(gray, p0, p1, (0, 0, 255)) cv2.line(gray, p0, p2, (0, 0, 255)) cv2.line(gray, p2, p1, (0, 0, 255)) return gray
def demo_aruco(image=None): marker_length = 0.5 if USE_CAMERA: cap = cv2.VideoCapture(0) else: cap = [] frame = image.copy() camera_matrix = numpy.array([[frame.shape[0], 0, frame.shape[1]], [0, frame.shape[0], frame.shape[1]], [0, 0, 1]]).astype(numpy.float64) dist = numpy.zeros((1, 5)) aruco_dict = aruco.Dictionary_get(aruco.DICT_6X6_250) while (True): if USE_CAMERA: ret, frame = cap.read() camera_matrix = numpy.array([[frame.shape[0], 0, frame.shape[1]], [0, frame.shape[0] , frame.shape[1] ], [0, 0, 1]]).astype(numpy.float64) dist = numpy.zeros((1, 5)) gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) gray_rgb = tools_image.desaturate(frame) corners, ids, rejectedImgPoints = aruco.detectMarkers(gray, aruco_dict) if len(corners) > 0: gray_rgb = aruco.drawDetectedMarkers(gray_rgb, corners) for each in corners: rvec, tvec, _ = aruco.estimatePoseSingleMarkers(each, marker_length, camera_matrix, dist) aruco.drawAxis(gray_rgb, camera_matrix, dist, rvec[0], tvec[0], marker_length/2) cv2.imshow('frame', gray_rgb) if cv2.waitKey(1) & 0xFF == 27: break if USE_CAMERA: cap.release() cv2.destroyAllWindows() cv2.imwrite(filename_out,gray_rgb) return
def draw_annotation(filaname_coco_annnotation, folder_images, folder_out, draw_binary_masks=False): coco = COCO(filaname_coco_annnotation) colors = tools_IO.get_colors(1 + len(coco.cats)) class_names = [coco.cats[key]['name'] for key in coco.cats] for key in coco.imgToAnns.keys(): annotations = coco.imgToAnns[key] image_id = annotations[0]['image_id'] filename = coco.imgs[image_id]['file_name'] if not os.path.isfile(folder_images + filename): continue boxes, category_IDs = [], [] for annotation in annotations: bbox = annotation['bbox'] boxes.append( [bbox[1], bbox[0], bbox[1] + bbox[3], bbox[0] + bbox[2]]) category_IDs.append(annotation['category_id']) if draw_binary_masks: image = cv2.imread(folder_images + filename) result = numpy.zeros_like(image) for box in boxes: top, left, bottom, right = box cv2.rectangle(result, (left, top), (right, bottom), (255, 255, 255), thickness=-1) cv2.imwrite(folder_out + filename.split('.')[0] + '.jpg', image) else: image = tools_image.desaturate(cv2.imread(folder_images + filename), level=0.8) result = tools_YOLO.draw_objects_on_image(image, boxes, [1] * len(boxes), category_IDs, colors, class_names) cv2.imwrite(folder_out + filename, result) 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