def deco_stretch(file, target_mean=None, target_sigma=None): data_input = file data_mean, data_std = cv2.meanStdDev(data_input) stretch = None pca_data = data_input.flatten() #np.asarray(data_input).reshape(-1) print(pca_data) pca_obj, pca_eigen, eigen_values = cv2.PCACompute2(pca_data, mean=target_mean) eig_data_sigma = np.sqrt(eigen_values) print(eig_data_sigma) scale = np.diag(1 / eig_data_sigma) print(scale) if target_sigma is None: stretch = np.diag(data_std) else: stretch = np.diag(target_sigma) stretch = np.float32(stretch) repmat_data = cv2.repeat(np.transpose(pca_obj), pca_data.shape[0], 1) zmat_data = cv2.subtract(pca_data, repmat_data, dtype=cv2.CV_32F) if target_mean is not None: repmat_data = cv2.repeat(np.transpose(target_mean), pca_data.shape[0], 1) transformed = zmat_data * (np.transpose(pca_eigen) * scale * pca_eigen * stretch) transformed = cv2.add(transformed, repmat_data, dtype=cv2.CV_32F) dstr32f = transformed.reshape(data_input.shape[0], -1, data_input.shape[2]) return dstr32f
def getBases(size, type=np.float64): B = np.ones((size * size, 6), dtype=type) row = np.ones((1, size), dtype=type) cols = np.ones((size, 1), dtype=type) for i in range(0, size): row[0, i] = i - np.floor(size / 2) cols[i, 0] = i - np.floor(size / 2) B[..., 1] = cv.repeat(row, size, 1).flatten() #x B[..., 2] = cv.repeat(cols, 1, size).flatten() #y B[..., 3] = B[..., 1] * B[..., 1] #x^2 B[..., 4] = B[..., 2] * B[..., 2] #y^2 B[..., 5] = B[..., 1] * B[..., 2] #xy return B
def dcs_transform(img, targetMean, targetSigma): # flatten to 2d data = img.reshape(-1, img.shape[-1]) # compute mean and stddev of input dataMu, dataSigma = cv2.meanStdDev(img) # compute pca mean = np.empty((0)) mean, eigenvectors, eigenvalues = cv2.PCACompute2(data, mean) # scaling matrix (Sc) eigDataSigma = np.sqrt(eigenvalues) scale = np.diagflat(1 / eigDataSigma) # stretching matrix (St) # if targetSigma is empty, set sigma of transformed data equal to that of original data if targetSigma is None: stretch = np.diagflat(dataSigma) else: stretch = np.diagflat(targetSigma) # stretching matrix (St) repMu = cv2.repeat(dataMu.T, data.shape[0], 1) zmudata = cv2.subtract(data.astype(float), repMu) if targetMean is not None: repMu = np.tile(targetMean.T, (data.shape[0], 1)) # compute pca transformation transformed = zmudata @ (eigenvectors.T @ scale @ eigenvectors @ stretch) transformed = np.add(transformed, repMu) return transformed.reshape(img.shape)
def train_scale(self, image, ini=False): xsf = self.get_scale_sample(image) # Adjust ysf to the same size as xsf in the first time if ini: totalSize = xsf.shape[0] self.ysf = cv2.repeat(self.ysf, totalSize, 1) # Get new GF in the paper (delta A) new_sf_num = cv2.mulSpectrums(self.ysf, xsf, 0, conjB=True) new_sf_den = cv2.mulSpectrums(xsf, xsf, 0, conjB=True) new_sf_den = cv2.reduce(real(new_sf_den), 0, cv2.REDUCE_SUM) if ini: self.sf_den = new_sf_den self.sf_num = new_sf_num else: # Get new A and new B self.sf_den = cv2.addWeighted(self.sf_den, (1 - self.scale_lr), new_sf_den, self.scale_lr, 0) self.sf_num = cv2.addWeighted(self.sf_num, (1 - self.scale_lr), new_sf_num, self.scale_lr, 0) self.update_roi()
def saveBackgrounds(self, bgs): nbgs = [len(e['bgs']) for e in bgs] cols = max(nbgs) fullR = nbgs.index(cols) fullBgs, mSep = [bgs[fullR][k] for k in ['bgs', 'mean_separator']] bg = self.bgrImg(self.bg_imgs.center) bg[:, :, :] = 255 h, w = bg.shape[:2] bg = cv2.repeat(bg, len(bgs), cols) for r, e in enumerate(bgs): ebgs = e['bgs'] for c, bg1 in enumerate(ebgs): if r != fullR: cD = c if len(ebgs) == len( fullBgs) else num.mean(bg1) > mSep bgD = num.absolute(bg1 - fullBgs[c]) rv, bg1 = cv2.threshold((bgD - bgD.min()) * 4, 255, 0, cv2.THRESH_TRUNC) x, y = c * w, r * h bg[y:y + h, x:x + w] = cv2.flip(self.bgrImg(bg1), 0) if c > 0: bg[y:y + h, x] = 255 if c + 1 == len(ebgs) and r > 0: bg[y, 0:cols * w] = 255 cv2.imwrite(self.get_filename_with_extension('_bg.png'), bg) with open(params.bgs_file, 'wb') as f: cPickle.dump( dict(recalc_n_frames=self.movie.recalc_n_frames(), backgrounds=bgs), f, -1)
def _add_high_iso_noise(x): noise = cv2.repeat(crop(noise_image, 300, 64), 15, 15) if x.shape[0] > noise.shape[0] or x.shape[1] > noise.shape[1]: raise Exception('Image too big for HIGH ISO noise') noise_patch = crop(noise, x.shape[0], min(1, abs(noise.shape[0] // 2 - x.shape[0]))) noise_patch = noise_patch.astype('float32') / (2 * 255) x = x[:, :, :3].astype('float32') / (255 * 2) res = np.array(x + noise_patch) #print(np.max(res)) return res
def Run(self, x=0, image=False): # Calibration. self.MainCalibration() if x == 1: self.StepCalibration() elif x == 2: self.SwerveCalibration() # Main execution. if image: # Generates new window. cv2.namedWindow('Running') while True: # Captures a camera frame. self.capture() # Makes a image copy. if image: res = cv2.repeat(self.img, 1, 1) else: res = 0 # Runs the main segmentation. M = self.MainRunning(res) if x == 1: # Runs the segmentation for the Step Challenge St = self.StepRunning(res) elif x == 2: # Runs the segmentation for the Swerve Challenge Sw = self.SwerveRunning(res) if image: # Shows image on screen. cv2.imshow('Running', cv2.resize(res, (int(len(res[0]) * self.scl), int(len(res) * self.scl)))) print "Main:", M, if x == 1: print "- Step:", St elif x == 2: print "- Swerve:", Sw else: print # Wait 'q' to be pressed if cv2.waitKey(20) & 0xFF == ord('q'): break # Closes all windows. cv2.destroyAllWindows()
def wallpaperSizeFitting(self): self.wp_resized = np.zeros(self.room.shape, np.uint8) #crop the wallpaper to fit the dimensions of the image (if it is oversized) if self.wallpaper.shape[0] > self.room.shape[ 0] or self.wallpaper.shape[1] > self.room.shape[1]: self.wp_resized = self.wallpaper[0:self.room.shape[0], 0:self.room.shape[1]] #iterates wallpaper to fill the dimensions of the image (if it is undersized) elif self.wallpaper.shape[0] < self.room.shape[ 0] or self.wallpaper.shape[1] < self.room.shape[1]: #another_wpmask = np.zeros((imgs_h,imgs_w),np.uint8) x_iter = (self.room.shape[0] // self.wallpaper.shape[0]) + 1 y_iter = (self.room.shape[1] // self.wallpaper.shape[1]) + 1 self.wp_resized = cv.repeat(self.wallpaper, x_iter, y_iter) self.wp_resized = self.wp_resized[0:self.room.shape[0], 0:self.room.shape[1]]
def get_blobs_info(cv_image): """ Gets information about the colored blobs in the image :param cv_image: The OpenCV image to get blobs from :return: A dictionary containing an array of points for each colored blob found, represented by its hue. For example, in an image with 2 red blobs and 3 blue blobs, it will return {0: [(639, 558), (702, 555)], 120: [(567, 550), (698, 515), (648, 515)]} """ # Show original image #cv2.imshow("Original image", cv_image) # Apply blur BLUR_SIZE = 3 cv_image_blur = cv2.GaussianBlur(cv_image, (BLUR_SIZE, BLUR_SIZE), 0) #cv2.imshow("Blur", cv_image_blur) # Apply ROI mask mask_path = rospkg.RosPack().get_path( 'sorting_demo') + "/share/head-mask.png" cv_mask = cv2.imread(mask_path) cv_mask = cv2.cvtColor(cv_mask, cv2.COLOR_BGR2GRAY) cv_image_masked = cv2.bitwise_and(cv_image_blur, cv_image_blur, mask=cv_mask) #cv2.imshow("Masked original", cv_image_masked) # HSV split cv_image_hsv = cv2.cvtColor(cv_image_masked, cv2.COLOR_BGR2HSV) cv_image_h, cv_image_s, cv_image_v = cv2.split(cv_image_hsv) #cv2.imshow("Image H", cv_image_h) #cv2.imshow("Image S", cv_image_s) #cv2.imshow("Image V", cv_image_v) # Apply CLAHE to Value channel CLAHE_SIZE = 16 clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(CLAHE_SIZE, CLAHE_SIZE)) cv_image_v_clahe = clahe.apply(cv_image_v) # Merge channels cv_image_clahe = cv2.merge((cv_image_h, cv_image_s, cv_image_v_clahe)) #cv2.imshow("CLAHE", cv_image_clahe) # Multiply Saturation and Value channels to separate the cubes, removing the table cv_image_sv_multiplied = cv2.multiply(cv_image_s, cv_image_v_clahe, scale=1 / 255.0) #cv2.imshow("Image S*V", cv_image_sv_multiplied) # Binarize the result BIN_THRESHOLD = 127 #ret, cv_image_binary = cv2.threshold(cv_image_sv_multiplied, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU) ret, cv_image_binary = cv2.threshold(cv_image_sv_multiplied, BIN_THRESHOLD, 255, cv2.THRESH_BINARY) #cv2.imshow("Threshold", cv_image_binary) # Calculate H-channel histogram, applying the binarized image as mask cv_image_h_histogram = cv2.calcHist([cv_image_h], [0], cv_image_binary, [256], [0, 255]) # Smoothen the histogram to find local maxima HISTOGRAM_BLUR_SIZE = 11 histogram_length = len(cv_image_h_histogram) cv_image_h_histogram_wrap = cv2.repeat(cv_image_h_histogram, 3, 1) cv_image_h_histogram_smooth = cv2.GaussianBlur( cv_image_h_histogram_wrap, (HISTOGRAM_BLUR_SIZE, HISTOGRAM_BLUR_SIZE), 0) cv_image_h_histogram_cut = cv_image_h_histogram_smooth[histogram_length:2 * histogram_length] # Collect high peaks PEAK_RATIO = 0.2 histogram_peak_cut = PEAK_RATIO * max(cv_image_h_histogram_cut) histogram_peaks = [ i for i in range(len(cv_image_h_histogram_cut)) if cv_image_h_histogram_cut[(i - 1) % histogram_length] < cv_image_h_histogram_cut[i] > cv_image_h_histogram_cut[ (i + 1) % histogram_length] ] histogram_high_peaks = filter( lambda x: cv_image_h_histogram_cut[x] > histogram_peak_cut, histogram_peaks) #print(histogram_high_peaks) #pyplot.plot(cv_image_h_histogram_cut) #pyplot.show() # Process every color found in the histogram blob_info = {} cv_image_contours_debug = cv2.cvtColor(cv_image_binary, cv2.COLOR_GRAY2BGR) for current_hue in histogram_high_peaks: # Perform a Hue rotation that will be used to make detecting the edge colors easier (red in HSV corresponds to both 0 and 180) HUE_AMPLITUDE = 5 cv_image_h_rotated = cv_image_h.copy() cv_image_h_rotated[:] -= current_hue cv_image_h_rotated[:] += HUE_AMPLITUDE # Binarize using range function cv_image_h_inrange = cv2.inRange(cv_image_h_rotated, 0, HUE_AMPLITUDE * 2) # Apply binary mask (consider that both black and the edge color have hue 0) cv_image_h_masked = cv2.bitwise_and(cv_image_h_inrange, cv_image_h_inrange, mask=cv_image_binary) # Erode EROSION_SIZE = 5 erosion_kernel = numpy.ones((EROSION_SIZE, EROSION_SIZE), numpy.uint8) cv_image_h_eroded = cv2.erode(cv_image_h_masked, erosion_kernel) #cv2.imshow("inRange {}".format(histogram_high_peaks.index(current_hue)), cv_image_h_eroded) # Find convex contours _, contours, _ = cv2.findContours(cv_image_h_eroded.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE) convex_contours = [cv2.convexHull(cnt) for cnt in contours] contour_color_hsv = numpy.array([[[current_hue, 255, 255]]], numpy.uint8) contour_color_rgb = cv2.cvtColor(contour_color_hsv, cv2.COLOR_HSV2BGR)[0][0].tolist() #cv2.drawContours(cv_image_contours_debug, convex_contours, -1, contour_color_rgb, 1) # Find centroids contour_moments = [cv2.moments(cnt) for cnt in convex_contours] contour_centroids = [(int(moments["m10"] / moments["m00"]), int(moments["m01"] / moments["m00"])) for moments in contour_moments if moments["m00"] != 0] for (cx, cy) in contour_centroids: cv2.circle(cv_image_contours_debug, (cx, cy), 3, contour_color_rgb, -1) # Collect data blob_info[current_hue] = contour_centroids #cv2.imshow("Convex contours", cv_image_contours_debug) return blob_info
import cv2 image = cv2.imread("images/flip_test.jpg", cv2.IMREAD_COLOR) if image is None: raise Exception("영상 파일 읽기 오류 발생") # 예외 처리 x_axis = cv2.flip(image, 0) # x축 기준 상하 뒤집기 y_axis = cv2.flip(image, 1) # y축 기준 좌우 뒤집기 xy_axis = cv2.flip(image, -1) rep_image = cv2.repeat(image, 1, 2) # 반복 복사 trans_image = cv2.transpose(image) # 행렬 전치 ## 각 행렬을 영상으로 표시 titles = ['images', 'x_axis', 'y_axis', 'xy_axis', 'rep_image', 'trans_image'] for title in titles: cv2.imshow(title, eval(title)) #eval => 문자열을 명령어로 만들어줌 . 즉 행렬 변수로 사용 cv2.waitKey(0)
def main(): fernew = open('fer2013new.csv') fer = open('fer2013.csv') reader1 = csv.reader(fernew, delimiter=',', quotechar='|') reader2 = csv.reader(fer, delimiter=',', quotechar='|') global all2 global diff train = [] validate = [] test = [] tv = [] total = [] multitrain = [] multivalidate = [] multitest = [] multitv = [] multitotal = [] for i, j in zip(reader1, reader2): all2 += 1 print all2 if i[0] == 'Usage': continue l = map(lambda x: int(x), i[2:]) # single label l1 = np.argmax(np.array(l)) l2 = int(j[0]) if l1 != fermap[l2]: diff += 1 if l1 > 7: l1 = fermap[l2] # multi label # determine face's existence by people judger if human_judger and l[-1] >= 5: continue multilabel = l[:-2] multis = sum(multilabel) if multis == 0: continue multilabel = map(lambda x: 1.0 * x / multis, multilabel) data = np.array(map(lambda x: int(x), j[1].split(' ')), dtype=np.uint8) data.resize(48, 48) # 直方图均衡化,效果不明显 # data = cv2.equalizeHist(data) gray_border = np.zeros((144, 144), np.uint8) cv2.repeat(data, 3, 3, gray_border) if i[0] == 'Training': D = range(0, 21, 5) D.extend(range(355, 339, -5)) for d in D: ret, line = writeOne(gray_border, l1, d) if ret: train.append(line) tv.append(line) total.append(line) multitrain.append(multilabel) multitv.append(multilabel) multitotal.append(multilabel) else: ret, line = writeOne(gray_border, l1, 0) if ret: total.append(line) multitotal.append(multilabel) if i[0] == 'PublicTest': validate.append(line) tv.append(line) multivalidate.append(multilabel) multitv.append(multilabel) elif i[0] == 'PrivateTest': test.append(line) multitest.append(multilabel) fernew.close() fer.close() print 'different:', diff print 'image data written completed' shuffleData('train', train, multitrain) shuffleData('validate', validate, multivalidate) shuffleData('test', test, multitest) shuffleData('total', total, multitotal) shuffleData('tv', tv, multitv)
def extendpat(pat,size): hr,wr = pat.shape wr = (size[0] - 1) // wr + 1 hr = (size[1] - 1) // hr + 1 return cv2.repeat(pat,hr,wr)[:size[1],:size[0]]
if __name__ == '__main__': syms = utils.gensymbol(23,SYMLEN,SYMNUM) print(syms) pats = list(map(lambda x: extendpat(genpat(x),(1024,1024)),syms)) cv2.imshow('dframe',pats[0].astype(np.uint8) + 128) cv2.waitKey(0) exit() #invc = cv2.VideoCapture('/home/user/Downloads/test.mkv') #invc = cv2.VideoCapture('/home/user/fin/MVI_9120.MOV') #for i in range(10): # _,sframe = invc.read() #_,sframe = invc.read() sframe = cv2.imread('/home/user/Downloads/1908084_740428942732671_7684358515802468396_n.jpg') sframe = cv2.repeat(sframe,5,5) off = 0 frame = sframe[:1024,off:1024 + off] #frame = cv2.cvtColor(frame,cv2.COLOR_RGB2HSV) #np.clip(frame[:,:,2] * 0.8 + 25.6 + (pats[0]),0,255,frame[:,:,2]) #frame = cv2.cvtColor(frame.astype(np.uint8),cv2.COLOR_HSV2RGB) cv2.imshow('o',frame) #cv2.imwrite('out.png',frame[:284,:253]) bri = cv2.cvtColor(frame,cv2.COLOR_RGB2HSV)[:,:,2] r,t = detch(bri) detpat(bri,r,t) '''
# Creates a window to show the robots vision. if args.show: cv2.namedWindow('Robot\'s Vision.') S = (-1, -1, 0) W = (-1, -1) mS = 0 while True: # Capture a frame from the camera. main.capture() # Copies the frame. if args.show: res = cv2.repeat(main.img, 1, 1) else: res = None # Executes the functions. M = main.MainRunning(res) if args.step: S = main.StepRunning(res) if args.swerve: W = main.SwerveRunning(res) # Refreshes the window. if args.show: cv2.imshow( 'Robot\'s Vision.', cv2.resize(
def extendpat(pat, size): hr, wr = pat.shape wr = (size[0] - 1) // wr + 1 hr = (size[1] - 1) // hr + 1 return cv2.repeat(pat, hr, wr)[:size[1], :size[0]]
def extendpat(pat,size): hr,wr = pat.shape wr = size[0] // wr hr = size[1] // hr return cv2.repeat(pat,hr,wr)
def cv_backproject(src): ntimes=len(src) tmp_array=src/float(ntimes) return cv2.repeat(tmp_array,1,ntimes)
import cv2 image = cv2.imread("dog.jpg", cv2.IMREAD_COLOR) if image is None: raise Exception("사진 에러") ''' cv2.flip(입력, 배열 뒤짚는 축) : 수직, 수평, 양축으로 뒤짚는다 각각 0, 1, -1 cv2.repeat(입력, 수직방향, 수평방향 반복횟수) : 입력 이미지를 반복하여 출력 cv2.transpose(입력) : 가로와 세로 방향을 바꿈 ''' x_axis = cv2.flip(image, 0) y_axis = cv2.flip(image, 1) xy_axis = cv2.flip(image, -1) rep_img = cv2.repeat(image, 2, 2) trans_img = cv2.transpose(image) titles = ["image", "x_axis", "y_axis", "xy_axis", "rep_img", "trans_img"] for title in titles: cv2.imshow(title, eval(title)) cv2.waitKey(0) cv2.destroyAllWindows()
def getPMatrix(mat): d = np.diag(mat).astype('float') rep = cv2.repeat(d, 1, len(d)) return mat/rep
def add_blue_hole(x): #xnew = x.copy() if len(x.shape) > 3: return np.array([_add_blue_hole(im) for im in x]) else: return _add_blue_hole(x) noise_image = np.ones((512, 512, 3)) try: noise_image = (plt.imread('../datasets/noise/101HPIMG/HPIM3024.JPG')[:,:,:3])*9 except FileNotFoundError: print('You do not have a noisy image sample') noise = cv2.repeat(crop(noise_image, 300, 64), 15, 15) def _add_high_iso_noise(x): if x.shape[0] > noise.shape[0] or x.shape[1] > noise.shape[1]: raise Exception('Image too big for HIGH ISO noise') return np.array(x + crop(noise, x.shape[0], min(1, abs(noise.shape[0]//2-x.shape[0])))) def add_high_iso_noise(x): if len(x.shape) > 3: return np.array([_add_high_iso_noise(im) for im in x]) else: return _add_high_iso_noise(x) def _add_blur(x): kernel_blur = np.ones((3,3))/(3**2) return conv2d(x, kernel_blur)