def refine_sky(bopt, image): sky_mask = make_mask(bopt, image) ground = np.ma.array(image,mask=cv2.cvtColor(cv2.bitwise_not(sky_mask), cv2.COLOR_GRAY2BGR)).compressed() sky = np.ma.array(image,mask=cv2.cvtColor(sky_mask, cv2.COLOR_GRAY2BGR)).compressed() ground.shape = (ground.size//3, 3) sky.shape = (sky.size//3, 3) ret, label, center = cv2.kmeans(np.float32(sky),2,None,(cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 10, 1.0),10,cv2.KMEANS_RANDOM_CENTERS) sigma_s1, mu_s1 = cv2.calcCovarMatrix(sky[label.ravel() == 0],None,cv2.COVAR_NORMAL | cv2.COVAR_ROWS | cv2.COVAR_SCALE) ic_s1 = cv2.invert(sigma_s1, cv2.DECOMP_SVD)[1] sigma_s2, mu_s2 = cv2.calcCovarMatrix(sky[label.ravel() == 1],None,cv2.COVAR_NORMAL | cv2.COVAR_ROWS | cv2.COVAR_SCALE) ic_s2 = cv2.invert(sigma_s2, cv2.DECOMP_SVD)[1] sigma_g, mu_g = cv2.calcCovarMatrix(ground,None,cv2.COVAR_NORMAL | cv2.COVAR_ROWS | cv2.COVAR_SCALE) icg = cv2.invert(sigma_g, cv2.DECOMP_SVD)[1] if cv2.Mahalanobis(mu_s1, mu_g, ic_s1) > cv2.Mahalanobis(mu_s2, mu_g, ic_s2): mu_s = mu_s1 sigma_s = sigma_s1 ics = ic_s1 else: mu_s = mu_s2 sigma_s = sigma_s2 ics = ic_s2 for x in range(image.shape[1]): cnt = np.sum(np.less(spatial.distance.cdist(image[0:bopt[x], x],mu_s,'mahalanobis',VI=ics),spatial.distance.cdist(image[0:bopt[x], x],mu_g,'mahalanobis',VI=icg))) if cnt < (bopt[x] / 2):bopt[x] = 0 return bopt
def find_matching_face(face_coefficients_to_match, coefficients_of_all_faces, covariance): # set up loop variables nearest_face_index = 0 nearest_face_distance = 100 # i.e. huge current_face = 0 for pca_face_coefficient in coefficients_of_all_faces: # calculate the Mahalanobis distamce between the coefficients we need to match and each from the set of faces # (skipping the first N eigenfaces that often contain just illumination variance, default N=3 ) m_dist = cv2.Mahalanobis( face_coefficients_to_match[:, args.eigenfaces_to_skip:args. eigenfaces], pca_face_coefficient.reshape( 1, args.eigenfaces)[:, args.eigenfaces_to_skip:args.eigenfaces], np.linalg.inv(covariance)) # alternatively use the L1 or L2 norm as per original [Pentland / Turk 1991] paper - which used L1 # m_dist = numpy.linalg.norm(face_coefficients_to_match[:,3:args.eigenfaces]-pca_face_coefficient.reshape(1,args.eigenfaces)[:,3:args.eigenfaces]) if (m_dist < nearest_face_distance): nearest_face_index = current_face nearest_face_distance = m_dist current_face += 1 return (nearest_face_index, nearest_face_distance)
def matchProfiles(model, profiles): tProfiles = np.zeros(profiles.shape[0]) for l in range(profiles.shape[0]): covar = model[0][l] mean = model[1][l] icovar = cv2.invert(covar, flags=cv2.DECOMP_SVD)[1] m = (profiles.shape[1] - 1) / 2 n = (model[1].shape[1] - 1) / 2 dist = np.zeros(2 * (m - n) + 1) for t in range(2 * (m - n) + 1): tMean = translateMean(mean, t, m) tIcovar = translateCovar(icovar, t, m) dist[t] = cv2.Mahalanobis(profiles[l], tMean, tIcovar) tProfiles[l] = m - n - np.argmin(dist) ''' PROFILE VISUALISATION ppl.vlines(np.arange(mean.shape[0]), np.zeros_like(mean), mean) ppl.show() ppl.vlines(np.arange(profiles[20].shape[0]), np.zeros_like(profiles[20]), profiles[20]) ppl.show() print tProfiles ''' return tProfiles
def true_sky(border, src_image): #制作天空图像掩码和地面图像掩码 sky_mask = make_sky_mask(src_image, border, 1) ground_mask = make_sky_mask(src_image, border, 0) #扣取天空图像和地面图像 sky_image_ma = np.ma.array(src_image, mask = cv2.cvtColor(sky_mask, cv2.COLOR_GRAY2BGR)) ground_image_ma = np.ma.array(src_image, mask = cv2.cvtColor(ground_mask, cv2.COLOR_GRAY2BGR)) #将天空和地面区域shape转换为n*3 sky_image = sky_image_ma.compressed() ground_image = ground_image_ma.compressed() sky_image.shape = (sky_image.size//3, 3) ground_image.shape = (ground_image.size//3, 3) # k均值聚类调整天空区域边界--2类 sky_image_float = np.float32(sky_image) criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 10, 1.0) flags = cv2.KMEANS_RANDOM_CENTERS compactness, labels, centers = cv2.kmeans(sky_image_float, 2, None, criteria, 10, flags) sky_label_0 = sky_image[labels.ravel() == 0] sky_label_1 = sky_image[labels.ravel() == 1] sky_covar_0, sky_mean_0 = cv2.calcCovarMatrix(sky_label_0, mean= None, flags= cv2.COVAR_ROWS + cv2.COVAR_NORMAL + cv2.COVAR_SCALE) sky_covar_1, sky_mean_1 = cv2.calcCovarMatrix(sky_label_1, mean= None, flags= cv2.COVAR_ROWS + cv2.COVAR_NORMAL + cv2.COVAR_SCALE) ground_covar, ground_mean = cv2.calcCovarMatrix(ground_image, mean= None, flags= cv2.COVAR_ROWS + cv2.COVAR_NORMAL + cv2.COVAR_SCALE) ic_s0 = cv2.invert(sky_covar_0, cv2.DECOMP_SVD)[1] ic_s1 = cv2.invert(sky_covar_1, cv2.DECOMP_SVD)[1] ic_g = cv2.invert(ground_covar, cv2.DECOMP_SVD)[1] #推断真实的天空区域 if cv2.Mahalanobis(sky_mean_0, ground_mean, ic_s0) > cv2.Mahalanobis(sky_mean_1, ground_mean, ic_s1): sky_mean = sky_mean_0 sky_covar = sky_covar_0 ic_s = ic_s0 else: sky_mean = sky_mean_1 sky_covar = sky_covar_1 ic_s = ic_s1 return sky_covar,sky_mean,ic_s,ground_covar, ground_mean,ic_g
import cv2 import numpy as np X = np.array([[0, 0, 0, 100, 100, 150, -100, -150], [0, 50, -50, 0, 30, 100, -20, -100]], dtype=np.float64) # 전치행렬 변경 X = X.transpose() # X = X.T cov, mean = cv2.calcCovarMatrix(X, mean=None, flags=cv2.COVAR_NORMAL + cv2.COVAR_ROWS) print('mean=', mean) print('cov=', cov) # 공분산 행렬 cov 의 역행렬 icov 계산 ret, icov = cv2.invert(cov) print('icov=', icov) v1 = np.array([[0], [0]], dtype=np.float64) v2 = np.array([[0], [50]], dtype=np.float64) # 벡터 v1, v2 사이의 마하라노비스 통계적 거리는 공분산 행렬의 # 역행렬을 이용해서 계산 dist = cv2.Mahalanobis(v1, v2, icov) print('dist = ', dist) cv2.waitKey() cv2.destroyAllWindows()
for i in range(0, len(digits)): if labels[i] == c: grouped_data[c].append(digits[i]) print 'group:', c, len(grouped_data[c]) x = np.array(grouped_data[c]) covar, mean = cv2.calcCovarMatrix(x, flags) icovar = np.empty(covar.shape, covar.dtype) cv2.invert(covar, icovar, cv2.DECOMP_SVD) icovariance.append(icovar) # # Q5: For each group, calculate the Mahalanobis distance of every element # to the centroid, then draw the centroid followed by the three farthest # elements (showing their Mahalanobis distance). # for index, centroid in enumerate(centroids): points = np.float32(grouped_data[index]) icovar = np.float32(icovariance[index]) mdistance = [] for point in points: mdistance.append(cv2.Mahalanobis(centroid, point, icovar)) farthest = sorted(mdistance, reverse=True)[:3] for far in farthest: print mdistance.index(far), far image_name = 'g' + str(index) + '_dist' + str(far) + '.png' draw_digit(points[mdistance.index(far)].tolist(), 200, True, True, image_name)
def process(self, inframe, outframe=None): """ Runs the pipeline and sets all outputs to new values. """ self.bgr_input = inframe.getCvBGR() # Step Resize_Image0: #self.__resize_image_input = inframe.getCvRGB() # Start measuring image processing time (NOTE: does not account for input conversion time): self.timer.start() # Step Blur0: self.__blur_input = self.bgr_input (self.blur_output) = self.__blur(self.__blur_input, self.__blur_type, self.__blur_radius) # Step HSL_Threshold0: self.__hsl_threshold_input = self.blur_output (self.hsl_threshold_output) = self.__hsl_threshold( self.__hsl_threshold_input, self.__hsl_threshold_hue, self.__hsl_threshold_saturation, self.__hsl_threshold_luminance) # Step CV_erode0: self.__cv_erode_0_src = self.hsl_threshold_output (self.cv_erode_0_output) = self.__cv_erode( self.__cv_erode_0_src, self.__cv_erode_0_kernel, self.__cv_erode_0_anchor, self.__cv_erode_0_iterations, self.__cv_erode_0_bordertype, self.__cv_erode_0_bordervalue) # Step CV_dilate0: self.__cv_dilate_src = self.cv_erode_0_output (self.cv_dilate_output) = self.__cv_dilate( self.__cv_dilate_src, self.__cv_dilate_kernel, self.__cv_dilate_anchor, self.__cv_dilate_iterations, self.__cv_dilate_bordertype, self.__cv_dilate_bordervalue) # Step CV_erode1: self.__cv_erode_1_src = self.cv_dilate_output (self.cv_erode_1_output) = self.__cv_erode( self.__cv_erode_1_src, self.__cv_erode_1_kernel, self.__cv_erode_1_anchor, self.__cv_erode_1_iterations, self.__cv_erode_1_bordertype, self.__cv_erode_1_bordervalue) # Step Find_Contours0: self.__find_contours_input = self.cv_erode_1_output (self.find_contours_output) = self.__find_contours( self.__find_contours_input, self.__find_contours_external_only) # Step Filter_Contours0: self.__filter_contours_contours = self.find_contours_output (self.filter_contours_output) = self.__filter_contours( self.__filter_contours_contours, self.__filter_contours_min_area, self.__filter_contours_min_perimeter, self.__filter_contours_min_width, self.__filter_contours_max_width, self.__filter_contours_min_height, self.__filter_contours_max_height, self.__filter_contours_solidity, self.__filter_contours_max_vertices, self.__filter_contours_min_vertices, self.__filter_contours_min_ratio, self.__filter_contours_max_ratio) # Step Convex_Hulls0: self.__convex_hulls_contours = self.filter_contours_output (self.convex_hulls_output) = self.__convex_hulls( self.__convex_hulls_contours) fps = self.timer.stop() numobjects = 0 M = [] #f = open("moments.txt", "a+") for contour in self.convex_hulls_output: #M.append(cv2.moments(contour)) M.append(cv2.HuMoments(cv2.moments(contour)).flatten()) #jevois.sendSerial(str(M[numobjects])) #for outputVal in M[numobjects]: #f.write(str(outputVal) + ', ') #f.write('\n') numobjects += 1 #f.close() serialMessage = ('Frame:' + str(self.frame) + str(self.frame) + ', Process Time:' + str(fps) + ', Objects:' + str(numobjects) + '=') if self.recordVideo is False and self.videoWriter is not None: #jevois.sendSerial('releasing video') self.videoWriter.release() self.videoWriter = None self.rawVideoWriter.release() self.rawVideoWriter = None self.hslVideoWriter.release() self.hslVideoWriter = None if outframe is not None or self.recordVideo is True: if self.recordVideo is True and self.videoWriter is None: timestamp = str(time.time()) os.makedirs('videos/' + timestamp) self.videoWriter = cv2.VideoWriter( 'videos/' + timestamp + '/processed.avi', cv2.VideoWriter_fourcc(*'XVID'), 22.0, (352, 288)) self.rawVideoWriter = cv2.VideoWriter( 'videos/' + timestamp + '/raw.avi', cv2.VideoWriter_fourcc(*'XVID'), 22.0, (352, 288)) self.hslVideoWriter = cv2.VideoWriter( 'videos/' + timestamp + '/hsl.avi', cv2.VideoWriter_fourcc(*'XVID'), 22.0, (352, 288)) #jevois.sendSerial(str(self.videoWriter.isOpened())) if self.recordVideo is True: self.rawVideoWriter.write(self.bgr_input) outimg = self.bgr_input printedData = False textHeight = 22 i = 0 for contour in self.convex_hulls_output: printedData = True x, y, w, h = cv2.boundingRect(contour) cv2.circle(outimg, (x + int(w / 2), y + int(h / 2)), 3, (255, 0, 0), 5) cv2.rectangle(outimg, (x, y), (x + w, y + h), (0, 255, 0), 3) mahalanobisVal = cv2.Mahalanobis(np.array(M[i]), np.array(self.momentAvg), np.array(self.invCovarMtrx)) serialMessage = serialMessage + ( '\nObject:' + str(i) + '[x:' + (str(x + int(w / 2)) + ',y:' + str(y + int(h / 2)) + ',w:' + str(w) + ',h:' + str(h) + ',m:' + str(mahalanobisVal) + ']')) cv2.putText(outimg, ('x: ' + str(x + int(w / 2)) + ', y: ' + str(y + int(h / 2)) + ', w: ' + str(w) + ', h: ' + str(h)), (3, 288 - textHeight), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA) textHeight = textHeight + 15 i += 1 if self.sendFrames: jevois.sendSerial(serialMessage) cv2.drawContours(outimg, self.convex_hulls_output, -1, (0, 0, 255), 3) cv2.putText(outimg, "Glitch CubeVision", (3, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA) # Write frames/s info from our timer into the edge map (NOTE: does not account for output conversion time): #height, width, channels = self.outimg.shape # if self.outimg is grayscale, change to: height, width = self.outimg.shape cv2.putText(outimg, fps, (3, 288 - 6), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA) # Convert our BGR output image to video output format and send to host over USB. If your output image is not # BGR, you can use sendCvGRAY(), sendCvRGB(), or sendCvRGBA() as appropriate: if outframe is not None: if self.displayHSLOutput: outframe.sendCvBGR( cv2.cvtColor(self.hsl_threshold_output, cv2.COLOR_GRAY2BGR)) else: outframe.sendCvBGR(outimg) if self.recordVideo is True: self.videoWriter.write(outimg) self.hslVideoWriter.write( cv2.cvtColor(self.hsl_threshold_output, cv2.COLOR_GRAY2BGR)) else: i = 0 for contour in self.convex_hulls_output: x, y, w, h = cv2.boundingRect(contour) mahalanobisVal = cv2.Mahalanobis(np.array(M[i]), np.array(self.momentAvg), np.array(self.invCovarMtrx)) serialMessage = serialMessage + ( '\nObject:' + str(i) + '[x:' + str(x + int(w / 2)) + ',y:' + str(y + int(h / 2)) + ',w:' + str(w) + ',h:' + str(h) + ',m:' + str(mahalanobisVal) + ']') i += 1 if self.sendFrames: jevois.sendSerial(serialMessage) self.frame += 1
def fit(self, img, verbose): """ fits the model to given image :param img: target image :type img: numpy.ndarray :param verbose: if the progress should be displayed :type verbose: bool :return: result of fitting :rtype: ASMFitResult """ # make sure image is in greyscale grey_img = img.copy() if len(grey_img.shape) == 3: grey_img = cv.cvtColor(grey_img, cv.COLOR_BGR2GRAY) # scale down the image ratio = math.sqrt(40000 / (grey_img.shape[0] * grey_img.shape[1])) new_w = int(grey_img.shape[1] * ratio) new_h = int(grey_img.shape[0] * ratio) resized_img = cv.resize(grey_img, (new_w, new_h)) # create temporary search model image cur_search = ModelImage() cur_search.shape_info = self.shape_info cur_search.image = resized_img # create fit result object for search params = np.zeros([1, self.eigenvalues.shape[0]]) sv = cur_search.shape_vector sv.set_from_vector(self.project_param_to_shape(params)[0]) st = sv.get_shape_transform_fitting_size(resized_img.shape) fit_result = ASMFitResult(params, st, self) cur_search.build_from_shape_vector(st) total_offset: int # sum of offsets of current iteration shape_old = ShapeVector() self.feature_extractor.load_image(resized_img) if verbose: cur_search.show(True, "resized image") for level in range(self.pyramid_level - 1, -1, -1): if verbose: print(f"Pyramid level: {level}\n") for run in range(10): shape_old.set_from_points_array( cur_search.points) # store old shape total_offset = 0 best_ep = np.zeros((self.n_landmarks, 2), np.int) # find best fit for every point for i in range(self.n_landmarks): if verbose: print(f"Fitting point {i}\n") cur_best = -1 best_i = 0 candidate_points, features = \ self.feature_extractor.get_candidates_with_feature(cur_search.points, i, level) # select best candidate point with Mahalanobis distance for j in range(len(candidate_points)): x = np.zeros(len(features[j])) for f, feature in enumerate(features[j]): x[f] = feature mean = self.mean_vec_pyr[level][i] inv_cov = self.cov_mat_pyr_inv[level][i] # ct = distance.mahalanobis(x, mean, inv_cov) ct = cv.Mahalanobis(x, mean, inv_cov) # if verbose: # print(f"Mahalanobis distance: {ct}") if ct < cur_best or cur_best < 0: cur_best = ct best_i = j best_ep[i, 0] = candidate_points[j][0] best_ep[i, 1] = candidate_points[j][1] total_offset += abs(best_i) # if : # cur_search.show(True) # modify results with factor of current pyramid level for i in range(self.n_landmarks): cur_search.points[i] = best_ep[i] x = int(cur_search.points[i, 0]) cur_search.points[i, 0] = x << level y = int(cur_search.points[i, 1]) cur_search.points[i, 1] = y << level if level > 0: cur_search.points[i, 0] += (1 << (level - 1)) cur_search.points[i, 1] += (1 << (level - 1)) cur_search.shape_vector.set_from_points_array( cur_search.points) # if verbose: # cur_search.show(True) # project found shape to PCA model and back to get parameters fit_result = self.find_params_for_shape( cur_search.shape_vector, shape_old, fit_result, level) # apply limits to found params for i, param in enumerate(fit_result.params[0]): if param < self.params_limits[i, 0]: fit_result.params[0, i] = self.params_limits[i, 0] if param > self.params_limits[i, 1]: fit_result.params[0, i] = self.params_limits[i, 1] cur_search.shape_vector.set_from_vector( cv.PCABackProject(fit_result.params, self.pca_shape_pyr[level], self.eigenvectors_pyr[level])[0]) cur_search.build_from_shape_vector(fit_result.similarity_trans) avg_mov = total_offset / self.n_landmarks if verbose: print(f"Iteration: {run + 1}, Average offset: {avg_mov}\n") cur_search.show(True, f"iteration {run + 1}") if avg_mov < 1.3: break if verbose: print( f"Finished fitting after {run + 1} iterations, Average offset of last iteration: {avg_mov}\n" ) cur_search.show(True, f"level {level} final fit") st_ = SimilarityTransformation() st_.a = 1 / ratio fit_result.similarity_trans = st_.multiply(fit_result.similarity_trans) return fit_result
ret, icov = cv2.invert(cov) dst = np.full((512, 512, 3), (255, 255, 255), dtype=np.uint8) rows, cols, channel = dst.shape centerX = cols // 2 centerY = rows // 2 v2 = np.zeros((2, 1), dtype=np.float64) FLIP_Y = lambda y: rows - 1 - y # draw Mahalanobis distance for y in range(rows): for x in range(cols): v2[0, 0] = x - centerX v2[1, 0] = FLIP_Y(y) - centerY # y-축 뒤집기 dist = cv2.Mahalanobis(mean, v2, icov) if dist < 0.1: dst[y, x] = [50, 50, 50] elif dist < 0.3: dst[y, x] = [100, 100, 100] elif dist < 0.8: dst[y, x] = [200, 200, 200] else: dst[y, x] = [250, 250, 250] for k in range(X.shape[0]): x, y = X[k, :] cx = int(x + centerX) cy = int(y + centerY) cy = FLIP_Y(cy) cv2.circle(dst, (cx, cy), radius=5, color=(0, 0, 255), thickness=-1)