def test(frame): hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) lower_white = np.array([0,0,200]) upper_white = np.array([300,100,300]) # Threshold the HSV image to get only white colors mask = cv2.inRange(hsv, lower_white, upper_white) gray = cv2.cvtColor(mask, cv2.COLOR_BAYER_GB2GRAY) gradX = cv2.Sobel(gray, ddepth = cv2.CV_32F, dx = 1, dy = 0, ksize = -1) gradY = cv2.Sobel(gray, ddepth = cv2.CV_32F, dx = 0, dy = 1, ksize = -1) # subtract the y-gradient from the x-gradient gradient = cv2.subtract(gradX, gradY) gradient = cv2.convertScaleAbs(gradient) # blur and threshold the image blurred=cv2.blur(gray,(9,9)) blurred = cv2.blur(gradient, (9, 9)) (_, thresh) = cv2.threshold(blurred, 225, 255, cv2.THRESH_BINARY) kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (21, 7)) closed = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel) # perform a series of erosions and dilations closed = cv2.erode(closed, None, iterations = 4) closed = cv2.dilate(closed, None, iterations = 4) image, contours,hierarchy= cv2.findContours(closed, cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE) img= cv2.drawContours(frame, contours, -1,(0,0,0),3) io.imshow(img)
def __getMask(self, image): """ Get binary mask of the image This algorithm has been referenced from http://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_imgproc/py_colorspaces/py_colorspaces.html """ hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV) lower_blue = np.array([115,50,50]) upper_blue = np.array([125,255,255]) lower_red = np.array([-3,50,50]) upper_red = np.array([3,255,255]) lower_green = np.array([50,50,50]) upper_green = np.array([70,255,255]) maskBlue = cv2.inRange(hsv, lower_blue, upper_blue) maskBlue = cv2.blur(maskBlue,(20,20)) ret, maskBlue = cv2.threshold(maskBlue,127,255,cv2.THRESH_BINARY) maskRed = cv2.inRange(hsv, lower_red, upper_red) maskRed = cv2.blur(maskRed,(20,20)) ret, maskRed = cv2.threshold(maskRed, 127, 255,cv2.THRESH_BINARY) return maskRed, maskBlue
def processImage(self, img): heading = 0 if self.size is None or self.size[0] != img.shape[0] or self.size[1] != img.shape[1]: h, w = img.shape[:2] self.size = (h, w) self.bin = np.empty((h, w, 1), dtype=np.uint8) temp = img targets = [] HIGH = 80 LOW = 10 cv2.blur(img, (7,7), dst=img) img = cv2.Canny(img, LOW, HIGH) cimg = cv2.cvtColor(img,cv2.COLOR_GRAY2BGR) #return img circles = cv2.HoughCircles(img, cv2.cv.CV_HOUGH_GRADIENT, 1, 10, param1=HIGH,param2=5,minRadius=1,maxRadius=500) if(circles == None): print "O nose!!!, nothing in circles!" return img print circles[0][0][0] x = circles[0][0][0] y = circles[0][0][1] radius = circles[0][0][2] cv2.circle(cimg, (x,y), 7, self.targetColor, thickness=radius) return cimg
def process(self, args): """ Use the Blur algorithm from the opencv package to the chosen colour channels of the current image. Args: | *args* : a list of arguments, e.g. image ndarray """ if (len(args[0].shape) == 2): self.result['img'] = cv2.blur(args[0], (self.kernelsize.value*2+1, self.kernelsize.value*2+1)) else: channels = cv2.split(args[0]) if self.channel1.value: channels[0] = cv2.blur(channels[0], (self.kernelsize.value*2+1, self.kernelsize.value*2+1)) if self.channel2.value: channels[1] = cv2.blur(channels[1], (self.kernelsize.value*2+1, self.kernelsize.value*2+1)) if self.channel3.value: channels[2] = cv2.blur(channels[2], (self.kernelsize.value*2+1, self.kernelsize.value*2+1)) self.result['img'] = cv2.merge(channels)
def processImage(t0, t1, t2): d1 = cv2.absdiff(t1, t0) d2 = cv2.absdiff(t2, t0) image = cv2.bitwise_and(d1, d2) image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY) image = cv2.blur(image, (5,5)) value, image = cv2.threshold(image, 25, 255, cv2.THRESH_BINARY) #element = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3,3)) #image = cv2.erode(image, element) image = cv2.blur(image, (5,5)) #image = cv2.normalize(image, 0., 1.) #mean, stddev = cv2.meanStdDev(image) #if stddev[0] > 40: # return image (minVal, maxVal, minLoc, maxLoc) = cv2.minMaxLoc(image) global cameraWidth, cameraHeight, x11 xDiv = (cameraWidth+1) / 7. yDiv = (cameraHeight+1) / 7. if maxVal > 100: if x11: image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB) cv2.rectangle(image, (maxLoc[0]-10,maxLoc[1]-10), (maxLoc[0]+20,maxLoc[1]+20), (0,0,255), 1) #print xLoc, yLoc global leftEye, rightEye leftEye.setPupilSmoothed(maxLoc[0] / xDiv, maxLoc[1] / yDiv) rightEye.setPupilSmoothed(maxLoc[0] / xDiv, maxLoc[1] / yDiv) return image
def get_blur(df_s, path): df_s = remove_weird_slice(df_s) Dset = [] for idx in range(len(df_s)): #Get brightest and darkest frames for study number idx #idx = 0 ext = df_s.index[idx] #print ext BT = np.argmax(df_s['brightness'][idx]) DK = np.argmin(df_s['brightness'][idx]) filename1 = os.listdir(path + '/' + ext)[BT] filename2 = os.listdir(path + '/' + ext)[DK] dcm1 = path + '/' + ext+ '/' + filename1 dcm2 = path + '/' + ext+ '/' + filename2 ds1 = dicom.read_file(dcm1) ds2 = dicom.read_file(dcm2) data1 = ds1.pixel_array data2 = ds2.pixel_array # plt.imshow(data1, cmap=plt.cm.bone) # plt.show() # plt.imshow(data2, cmap=plt.cm.bone) # plt.show() datab1 = cv2.blur(data1,(7,7)) datab2 = cv2.blur(data2,(7,7)) #D is delta between brightest and darkest image for a slice D = abs(datab2.astype(int) - datab1.astype(int)) Dset.append(D) #plt.imshow(D, cmap=plt.cm.bone) #plt.show() #Average deltas for all slices gives region of movement return np.mean(np.array(Dset), axis = 0)
def cropped_bg_sum1(): """ desc: pass the cropped image through the background summation algorithm "bg_subber_sum1" from yesterday, though blur it first. date: 5/2/14 source: Ian Burnett result: It worked. The algorithm barely squeaks by, but the cropping the image was super helpful. And when I crop a different spot, the whole thing becomes why pretty quickly, which is definitely a good sign. """ fgbg = cv2.BackgroundSubtractorMOG(500, 6, 0.9, 1) _, f = video.read() f = crop_spot(f) f = cv2.blur(f,(18,18)) # this was super effective too f = cv2.blur(f,(16,16)) f = fgbg.apply(f) for i in xrange(200): _, frame = video.read() cropped = crop_spot(frame) fg_mask = fgbg.apply(cropped) if i % 5 == 0: print i, f = cv2.add(f, fg_mask) cv2.imshow('frame', f) c = cv2.waitKey(1) if c == 27: break cv2.destroyAllWindows() plt.subplot(1,1,1), plt.imshow(f, 'gray') plt.xticks([]), plt.yticks([]) plt.show()
def imgproc(frame): # convert color to gray scale and show it gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) cv2.imshow('gray', gray) blur = cv2.blur(gray, (5, 5)) edge = cv2.Canny(blur, 10, 100) edge = cv2.blur(edge, (2, 2)) cv2.imshow('blured edge', edge) # convert image to black and white and show it thresh1, thresh = cv2.threshold(edge, 60, 120, cv2.THRESH_BINARY) cv2.imshow('thresh', thresh) # find contours! contours, hry = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) # draw all the contours cpframe = frame.copy() cv2.drawContours(cpframe, contours, -1, (0, 255, 0), 3) cv2.imshow('cpframe', cpframe) # ================== TODO =================== # Modify these code to suit your need contours = [ctr for ctr in contours if cv2.contourArea(ctr) > 100] contours = [cv2.approxPolyDP(ctr, 5, True) for ctr in contours] contours = [ctr for ctr in contours if len(ctr) == 4] contours = [ctr for ctr in contours if cv2.isContourConvex(ctr)] # ============================================ # draw on the frame cv2.drawContours(frame, contours, -1, (0, 255, 0), 3) return frame
def activeContour(image, snaxels): """ Iterate the contour until the energy reaches an equilibrium """ energy_matrix = np.zeros( (_MAX_SNAXELS - 1, _NUM_NEIGHBORS, _NUM_NEIGHBORS), dtype=np.float32) position_matrix = np.zeros( (_MAX_SNAXELS - 1, _NUM_NEIGHBORS, _NUM_NEIGHBORS, 2), dtype=np.int32 ) neighbors = np.array([[i, j] for i in range(-1, 2) for j in range(-1, 2)]) min_final_energy_prev = float("inf") counter = 0 smooth_factor = _INITIAL_SMOOTH iterations = _INITIAL_ITERATIONS gradient_image = _gradientImage(image) smooth_image = cv.blur(gradient_image, (smooth_factor, smooth_factor)) while True: counter += 1 if not (counter % iterations): iterations += _ITERATIONS_DELTA if smooth_factor > _SMOOTH_FACTOR_DELTA: smooth_factor -= _SMOOTH_FACTOR_DELTA smooth_image = cv.blur(gradient_image, (smooth_factor, smooth_factor)) print "Deblur step, smooth factor now: ", smooth_factor _display(smooth_image, snaxels) min_final_energy = _iterateContour(image, smooth_image, snaxels, energy_matrix, position_matrix, neighbors) if (min_final_energy == min_final_energy_prev) or smooth_factor < _SMOOTH_FACTOR_DELTA: print "Min energy reached at ", min_final_energy print "Final smooth factor ", smooth_factor break else: min_final_energy_prev = min_final_energy
def getboxes(img, b_tuple, count): lower = np.array(b_tuple[0], dtype = "uint8") upper = np.array(b_tuple[1], dtype = "uint8") mask = cv2.inRange(img, lower, upper) output = cv2.bitwise_and(img, img, mask = mask) # output = cv2.resize(output, None, fx = 0.1, fy = 0.1, interpolation = cv2.INTER_CUBIC) cv2.imshow("ii", np.hstack([img, output])) cv2.waitKey(0) gray_img = cv2.cvtColor(output, cv2.COLOR_BGR2GRAY) gray_img = cv2.blur(gray_img, (5,5)) gray_img = cv2.bilateralFilter(gray_img, 20, 20, 20) edged = cv2.Canny(gray_img, 30, 200) edged = cv2.blur(edged, (5,5)) cv2.imshow("ii", edged) cv2.waitKey(0) contours, _ = cv2.findContours(edged.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) contours = sorted(contours, key = cv2.contourArea, reverse = True)[:count] #cv2.drawContours(img, contours, -1, (0,255,0), 3) cv2.imshow("ii", img) cv2.waitKey(0) boxes = [] for i in range(0, count): rect = cv2.minAreaRect(contours[i]) box = cv2.cv.BoxPoints(rect) box = np.int0(box) boxes.append(box) #pprint(boxes) return boxes
def get_slc_blur(solid, brightness): #better to just take data? #df_s = remove_weird_slice(df_s) Dset = [] BT = np.argmax(brightness) DK = np.argmin(brightness) #filename1 = fileset[BT] #filename2 = fileset[DK] #dcm1 = filename1 #dcm2 = filename2 #ds1 = dicom.read_file(dcm1) #ds2 = dicom.read_file(dcm2) data1 = solid[BT] data2 = solid[DK] # plt.imshow(data1, cmap=plt.cm.bone) # plt.show() # plt.imshow(data2, cmap=plt.cm.bone) # plt.show() datab1 = cv2.blur(data1,(7,7)) datab2 = cv2.blur(data2,(7,7)) #D is delta between brightest and darkest image for a slice return abs(datab2.astype(int) - datab1.astype(int))
def best_size_offset(image, template, width_nom, threshold, audible = False, fast = False): import numpy as np import cv2 offsets = np.linspace(-0.3, 0.3, 25) best_offset = 0 most_matches = 0 n_zeros = 0 template = template width_nom = width_nom threshold = threshold for size_off in offsets: img3 = cv2.resize(image, (0,0), fx=width_nom + size_off, fy=width_nom + size_off) img3 = cv2.blur(img3, (2,2)) res = cv2.matchTemplate(img3, template, cv2.TM_CCOEFF_NORMED) good_matches = sum(sum(res > threshold)) if good_matches > most_matches: most_matches = good_matches best_offset = size_off n_zeros = 0 if (most_matches > 0) & (good_matches == 0): n_zeros += 1 if n_zeros > 2: break if audible: print "Sizing offset: " + str(size_off) + " :: " + str(good_matches) if audible: print "--------------------------------" print "Best offset: " + str(best_offset) + "(" + str(most_matches) + ")" print "--------------------------------" if fast: print(round(best_offset, 4)) return(round(best_offset, 4)) small_step_offsets = np.linspace(best_offset - 0.015, best_offset + 0.015, 13) best_offset = 0 most_matches = 0 for size_off in small_step_offsets: img3 = cv2.resize(image, (0,0), fx=width_nom + size_off, fy=width_nom + size_off) img3 = cv2.blur(img3, (2,2)) res = cv2.matchTemplate(img3, template, cv2.TM_CCOEFF_NORMED) good_matches = sum(sum(res > threshold)) if good_matches > most_matches: most_matches = good_matches best_offset = size_off if audible: print "Sizing offset: " + str(size_off) + " :: " + str(good_matches) if audible: print "--------------------------------" print "Best offset: " + str(best_offset) + "(" + str(most_matches) + ")" print "--------------------------------" print(round(best_offset, 4)) return(round(best_offset, 4))
def mean(image,params): if params['kernel_shape'] == 'rect': try: return cv2.blur(image,(params['kernel_size_x'],params['kernel_size_y'])) except: return cv2.blur(scale_data(image,16),(params['kernel_size_x'],params['kernel_size_y'])) else: sys.stderr.write("kernel shape handler not implemented:"+kernel['shape'])
def _computeCoefficients(self, p): r = self._radius p_mean = cv2.blur(p, (r, r)) p_cov = p_mean - self._I_mean * p_mean a = p_cov / (self._I_var + self._epsilon) b = p_mean - a * self._I_mean a_mean = cv2.blur(a, (r, r)) b_mean = cv2.blur(b, (r, r)) return a_mean, b_mean
def calcul_similarite(self, n=20, p=30): """ Question 1.2 Trace les fenêtres de plus grandes similarités entre les deux images. Parameters ---------- n: largeur des fenêtres p: hauteur des fenêtres """ # Dans un premier temps on récupère la liste de tous les points d'importance des images 1 et 2 corners1 = self.corner_method(self.img1) corners2 = self.corner_method(self.img2) for corner in corners1: x, y = corner.ravel() cv2.circle(self.img1, (x, y), 1, 255, -1) for corner in corners2: x, y = corner.ravel() cv2.circle(self.img2, (x, y), 1, 255, -1) # Puis pour chaque point des listes corners, on fait une fenêtre de taille (2N+1)x(2P+1) # On stocke ces fenêtres dans deux listes contenant les intensités des # points de cette fenêtre blur1 = cv2.blur(self.img1, (3, 3), 0) blur2 = cv2.blur(self.img2, (3, 3), 0) list_windows1 = self.window_around(blur1, corners1, n, p) list_windows2 = self.window_around(blur2, corners2, n, p) # On initialise le maximum avec une valeur très élevée afin d'être sûr # d'obtenir un minimum par la suite max_similarity = 10000000000 # On va ensuite calculer la similarité de chaque combinaison possible de fenêtre de corner dans les deux images # On ne gardera que les points extrêmes de chaque fenêtre minimisant la dissimilarité for window1, point11, point12 in list_windows1: for window2, point21, point22 in list_windows2: similarity = self.cost(window1, window2, type=self.type) if similarity < max_similarity: max_similarity = similarity print max_similarity image_1_top_left = point11 image_1_bot_right = point12 image_2_top_left = point21 image_2_bot_right = point22 # On plot en dessous d'un certain seuil afin d'afficher plusieurs points de similarité if max_similarity < 150000: self.plot_windows(self.img1, self.img2, image_1_top_left, image_1_bot_right, image_2_top_left, image_2_bot_right) print "similarité finale : ", max_similarity
def augmentation_wrapper(X_list, y_list): import random for index, y in enumerate(y_list): X = np.copy(X_list[index]) # Adjust the exposure X_Lab = cv2.cvtColor(X, cv2.COLOR_BGR2LAB) X_L = X_Lab[:, :, 0].astype(dtype=np.float32) # margin = np.min([np.min(X_L), 255.0 - np.max(X_L), 64.0]) margin = 128.0 exposure = random.uniform(-margin, margin) X_L += exposure X_L = np.around(X_L) X_L[X_L < 0.0] = 0.0 X_L[X_L > 255.0] = 255.0 X_Lab[:, :, 0] = X_L.astype(dtype=X_Lab.dtype) X = cv2.cvtColor(X_Lab, cv2.COLOR_LAB2BGR) # Rotate and Scale h, w, c = X.shape degree = random.randint(-30, 30) scale = random.uniform(0.80, 1.25) padding = np.sqrt((w) ** 2 / 4 - 2 * (w) ** 2 / 16) padding /= scale padding = int(np.ceil(padding)) for channel in range(c): X_ = X[:, :, channel] X_ = np.pad(X_, padding, 'reflect', reflect_type='even') h_, w_ = X_.shape # Calulate Affine transform center = (w_ // 2, h_ // 2) A = cv2.getRotationMatrix2D(center, degree, scale) X_ = cv2.warpAffine(X_, A, (w_, h_), flags=cv2.INTER_LANCZOS4, borderValue=0) X_ = X_[padding: -1 * padding, padding: -1 * padding] X[:, :, channel] = X_ # Horizontal flip if random.uniform(0.0, 1.0) <= 0.5: X = cv2.flip(X, 1) if ':' in y: species, viewpoint = y.split(':') viewpoint = label_mapping_dict[viewpoint] y = '%s:%s' % (species, viewpoint) # Blur if random.uniform(0.0, 1.0) <= 0.1: if random.uniform(0.0, 1.0) <= 0.5: X = cv2.blur(X, (3, 3)) else: X = cv2.blur(X, (5, 5)) # Reshape X = X.reshape(X_list[index].shape) # Show image # canvas = np.hstack((X_list[index], X)) # cv2.imshow('', canvas) # cv2.waitKey(0) # Save X_list[index] = X y_list[index] = y return X_list, y_list
def get_blurred_field(video, upper_left, lower_right, blur, brightness): middle_mat = np.zeros(video.shape, dtype=np.float32) cv2.rectangle(middle_mat, upper_left, lower_right, (1.0, 1, 1), thickness=-1) middle_mat = cv2.blur(middle_mat, (20, 20)) middle_field_vid = cv2.blur(video, (int(blur), int(blur))) middle_field_vid = cv2.multiply(middle_field_vid, brightness * middle_mat, dtype=3) rest_vid = cv2.multiply(video, 1 - middle_mat, dtype=3) return cv2.add(middle_field_vid, rest_vid)
def localSD(mat, n): mat=np.float32(mat) mu = cv2.blur(mat,(n,n)) mdiff=mu-mat mat2=cv2.blur(np.float64(mdiff*mdiff),(n,n)) sd = np.float32(cv2.sqrt(mat2)) sdn=normalize(sd) return sdn
def getCoordinates(self,target="ball",debug=False): """ This function searches for the target (ball/yellow gate/blue gate). It's done by the using thresholds and contour searching. Counter with the biggest area is chosen. First thresholding """ #Initial ball position (not on the image) x=-1 y=-1 #Convert to HSV space and blur the image to reduce color noise hsv_frame=cv2.cvtColor(self.frame,cv2.COLOR_BGR2HSV) cv2.blur(hsv_frame, (1, 1), hsv_frame) if target == "ball": self.thresholded_frame = cv2.inRange(hsv_frame, self.ball_threshold_low, self.ball_threshold_high) elif target == "blue gate": self.thresholded_frame = cv2.inRange(hsv_frame, self.blue_gate_threshold_low, self.blue_gate_threshold_high) else: #yellow gate self.thresholded_frame = cv2.inRange(hsv_frame, self.yellow_gate_threshold_low, self.yellow_gate_threshold_high) #Erode the image (what ever it means) frame_contours = cv2.erode(self.thresholded_frame, None) if debug: cv2.imshow("Thresholded",self.thresholded_frame) """ Finding a contour with the biggest area """ contours, hierarchy = cv2.findContours(frame_contours, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE) contourareamax = 0 maxcontour = 0 for i in contours: contourarea = cv2.contourArea(i) if contourarea > contourareamax: maxcontour = i contourareamax = contourarea #Find the center point of the contour try: if contourarea > 5: center, radius = cv2.minEnclosingCircle(maxcontour) #cv2.boundingRect(contourareamax) x, y = center if debug: cv2.circle(self.frame, (int(x), int(y)), int(radius), (100, 100, 255)) except: print "Can't find the minimum enclosing circle" if debug: cv2.imshow("Camera",self.frame) return x,y
def doThings(self): sgbm = cv2.StereoSGBM() sgbm.SADWindowSize, numberOfDisparitiesMultiplier, sgbm.preFilterCap, sgbm.minDisparity, \ sgbm.uniquenessRatio, sgbm.speckleWindowSize, sgbm.P1, sgbm.P2, \ sgbm.speckleRange = [v for v,_ in self.params.itervalues()] sgbm.numberOfDisparities = numberOfDisparitiesMultiplier*16 sgbm.disp12MaxDiff = -1 sgbm.fullDP = False R1, R2, P1, P2, Q, topValidRoi, bottomValidRoi = cv2.stereoRectify(self.M1, self.D1, self.M2, self.D2, (self.top.shape[1],self.top.shape[0]), self.R, self.T, flags=cv2.CALIB_ZERO_DISPARITY, alpha=0) top_map1, top_map2 = cv2.initUndistortRectifyMap(self.M1, self.D1, R1, P1, (self.top.shape[1],self.top.shape[0]), cv2.CV_16SC2) bottom_map1, bottom_map2 = cv2.initUndistortRectifyMap(self.M2, self.D2, R2, P2, (self.bottom.shape[1], self.bottom.shape[0]), cv2.CV_16SC2) self.top_r = cv2.remap(self.top, top_map1, top_map2, cv2.cv.CV_INTER_LINEAR); self.bottom_r = cv2.remap(self.bottom, bottom_map1, bottom_map2, cv2.cv.CV_INTER_LINEAR) top_small = cv2.resize(self.top_r, (self.top_r.shape[1]/2,self.top_r.shape[0]/2)) bottom_small = cv2.resize(self.bottom_r, (self.bottom_r.shape[1]/2,self.bottom_r.shape[0]/2)) cv2.imshow('top', top_small); cv2.imshow('bottom', bottom_small); # top_r = cv2.equalizeHist(top_r) top_r = cv2.blur(self.top_r, (5,5)) # bottom_r = cv2.equalizeHist(bottom_r) bottom_r = cv2.blur(self.bottom_r, (5,5)) dispTop = sgbm.compute(top_r.T, bottom_r.T).T; dispTopPositive = dispTop dispTopPositive[dispTop<0] = 0 disp8 = (dispTopPositive / (sgbm.numberOfDisparities * 16.) * 255).astype(np.uint8); disp_small = cv2.resize(disp8, (disp8.shape[1]/2, disp8.shape[0]/2)); cv2.imshow(self.winname, disp_small); self.disp8 = disp8 self.xyz = cv2.reprojectImageTo3D(dispTop, Q, handleMissingValues=True) # self.xyzrgb = np.zeros((self.xyz.shape[0],self.xyz.shape[1],4)) # import struct # def color_to_float(color): # if color.size == 1: # color = [color]*3 # rgb = (color[2] << 16 | color[1] << 8 | color[0]); # rgb_hex = hex(rgb)[2:-1] # s = '0'*(8-len(rgb_hex)) + rgb_hex.capitalize() ## print color, rgb, hex(rgb) # rgb_float = struct.unpack('!f', s.decode('hex'))[0] ## print rgb_float # return rgb_float # for i in range(self.xyz.shape[0]): # for j in range(self.xyz.shape[1]): # self.xyzrgb[i,j] = np.append(self.xyz[i,j], color_to_float(self.top[i,j]))
def color_detection_hsv(self, frame, thresholdminvalues, thresholdmaxvalues): ''' (np.array np.uint8 3channel, list of 3 ints, list of 3 ints) -> np.array np.uint8 1channel''' ''' Return thresholded_frame according to thresholdmin/maxvalues''' hsv_frame=cv2.cvtColor(frame,cv2.COLOR_BGR2HSV) #convert the image to hsv(Hue, Saturation, Value) so its easier to determine the color to track(hue) cv2.blur(hsv_frame, (3, 3), hsv_frame) # TESTing needed does blurring has an effect. colormin = np.asarray(thresholdminvalues, np.uint8) colormax = np.asarray(thresholdmaxvalues, np.uint8)# ball color thresholded_frame = cv2.inRange(hsv_frame, colormin, colormax) if self.debug: cv2.imshow("Thresholded",thresholded_frame) return thresholded_frame
def flow(image): global opflow_first global previous src = image.copy() if (opflow_first): if (previous == None): previous = src.copy() opflow_first = 0 del src return criteria = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 20, 0.03) lk_params = dict(winSize = (31,31), maxLevel = 5, criteria = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 20, 0.03)) img1 =cv2.cvtColor(previous, cv2.COLOR_BGR2GRAY) img1= cv2.blur(img1,(5,5)) img2 =cv2.cvtColor(src, cv2.COLOR_BGR2GRAY) img2= cv2.blur(img2,(5,5)) numpoints = 90 p0 = cv2.goodFeaturesToTrack(img1, numpoints, .01, .01) if (len(p0)>0): cv2.cornerSubPix(img1, p0, (15,15), (-1,-1), criteria) p1, st, error = cv2.calcOpticalFlowPyrLK(img1, img2, p0, None, **lk_params) for i in range(numpoints): if (st[i] == 0): p = (int(p0[i][0][0]), int(p0[i][0][1])) q = (int(p1[i][0][0]), int(p1[i][0][1])) cv2.circle(src, p, 5, (255,255,0), -1) cv2.circle(src, q, 5, (0,255,255), -1) line_thickness = 1 line_color = (0, 0, 255) p = (int(p0[i][0][0]), int(p0[i][0][1])) q = (int(p1[i][0][0]), int(p1[i][0][1])) cv2.circle(src, p, 5, (0,255,0), -1) cv2.circle(src, q, 5, (255,0,0), -1) cv2.line(src, p, q, line_color, line_thickness, 0) previous = image.copy() del img1 del img2 return src
def process_one_video(self, v): fn = os.path.basename(v) fn = os.path.splitext(fn)[0] # get name without suffix print fn # start to process video cap = cv2.VideoCapture(v) fgbg = cv2.BackgroundSubtractorMOG() count = 0 video_length = cap.get(cv2.cv.CV_CAP_PROP_FRAME_COUNT) while (count < video_length - 10): count += 1 ret, frame = cap.read() # use org_frame to generate neg img check_frame = frame org_frame = frame # process after 50 frames if count > 50: frame = cv2.blur(frame, (3, 3)) fgmask = fgbg.apply(frame, learningRate=0.001) if count > 600: if count % 10 != 0: # jump every 10 frames continue fgmask = cv2.blur(fgmask, (3, 3)) contoured = np.copy(fgmask) contours, _ = cv2.findContours(contoured, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE) tmp_img_name = fn + '_' + str(count) + '.jpg' tmp_save_flag = False for cnt in contours: x, y, w, h = cv2.boundingRect(cnt) if x < ROI_X_MIN or x > ROX_X_MAX or y < ROI_Y_MIN or y > ROI_Y_MAX: continue tmp_size = w * h if tmp_size < PERSON_SIZE_MAX and tmp_size > PERSON_SIZE_MIN: if tmp_img_name not in self.old_pos_dict: self.old_pos_dict[tmp_img_name] = [[x, y, w, h]] else: self.old_pos_dict[tmp_img_name].append([x, y, w, h]) # mark box cv2.rectangle(check_frame, (x, y), (x + w, y + h), (255, 0, 0), thickness=2) print tmp_size, count, fn tmp_save_flag = True if tmp_save_flag: # get one neg box tmp_x = randint(0, 350) tmp_y = randint(0, 200) cv2.rectangle(check_frame, (tmp_x, tmp_y), (tmp_x + NEG_IMG_WIDTH, tmp_y + NEG_IMG_WIDTH), (0, 0, 255), thickness=2) self.old_neg_dict[tmp_img_name] = [[tmp_x, tmp_y, NEG_IMG_WIDTH, NEG_IMG_WIDTH]] cv2.imwrite(os.path.join(self.check_img_dir, tmp_img_name), check_frame) # save img for check cv2.imwrite(os.path.join(self.work_img_dir, tmp_img_name), org_frame) # save origin img if count % 400 == 0: print 'now process frame', count, fn
def opencv_show_detailed(self): pos = 0 image = self.image.copy() name = 'image' cv2.destroyWindow(name) cv2.imshow(name, image) cv2.moveWindow(name, pos, 0) pos += 150 name = 'edges: %d %d %d' % cannyrows(self.edges()) edgesimage = self.edges().copy() cv2.circle(edgesimage, self.center(), 1, 255) cv2.destroyWindow(name) cv2.imshow(name, edgesimage) cv2.moveWindow(name, pos, 0) pos += 150 blur = cv2.blur(self.gray(), ksize=(4,4)) name = 'blur' cv2.destroyWindow(name) cv2.imshow(name, blur) cv2.moveWindow(name, pos, 0) blur2 = cv2.blur(self.gray(), ksize=(6,6)) name = 'blur2' cv2.destroyWindow(name) cv2.imshow(name, blur) cv2.moveWindow(name, pos, 200) pos += 150 for p in self.params: canny = cv2.Canny(blur, 404*p, 156*p, apertureSize=3) r1,r2,r3 = cannyrows(canny) name = 'bc %.3f %d %d %d' % (p, r1,r2,r3) cv2.destroyWindow(name) cv2.imshow(name, canny) cv2.moveWindow(name, pos, 0) canny = cv2.Canny(blur2, 404*p, 156*p, apertureSize=3) r1,r2,r3 = cannyrows(canny) name = 'bc2 %.3f %d %d %d' % (p, r1,r2,r3) cv2.destroyWindow(name) cv2.imshow(name, cv2.Canny(blur2, 404*p, 156*p, apertureSize=3)) cv2.moveWindow(name, pos, 200) canny = cv2.Canny(self.gray(), 404*p, 156*p, apertureSize=3) r1,r2,r3 = cannyrows(canny) name = 'c %.3f %d %d %d' % (p, r1,r2,r3) cv2.destroyWindow(name) cv2.imshow(name, cv2.Canny(self.gray(), 404*p, 156*p, apertureSize=3)) cv2.moveWindow(name, pos, 400) pos += 150
def _computeCoefficients(self, p): r = self._radius I = self._I Ir, Ig, Ib = I[:, :, 0], I[:, :, 1], I[:, :, 2] p_mean = cv2.blur(p, (r, r)) Ipr_mean = cv2.blur(Ir * p, (r, r)) Ipg_mean = cv2.blur(Ig * p, (r, r)) Ipb_mean = cv2.blur(Ib * p, (r, r)) Ipr_cov = Ipr_mean - self._Ir_mean * p_mean Ipg_cov = Ipg_mean - self._Ig_mean * p_mean Ipb_cov = Ipb_mean - self._Ib_mean * p_mean ar = self._Irr_inv * Ipr_cov + self._Irg_inv * Ipg_cov + self._Irb_inv * Ipb_cov ag = self._Irg_inv * Ipr_cov + self._Igg_inv * Ipg_cov + self._Igb_inv * Ipb_cov ab = self._Irb_inv * Ipr_cov + self._Igb_inv * Ipg_cov + self._Ibb_inv * Ipb_cov b = p_mean - ar * self._Ir_mean - ag * self._Ig_mean - ab * self._Ib_mean ar_mean = cv2.blur(ar, (r, r)) ag_mean = cv2.blur(ag, (r, r)) ab_mean = cv2.blur(ab, (r, r)) b_mean = cv2.blur(b, (r, r)) return ar_mean, ag_mean, ab_mean, b_mean
def score_gauss(self, idata): ''' Find the difference between a point and its gaussian idata: ImageMeta().data yields: 1d integer numpy array for each axis, y then x ''' idata = cv2.cvtColor(idata, cv2.cv.CV_BGR2Lab) big = numpy.array(cv2.blur(idata, (11, 11)), dtype=numpy.int16) little = numpy.array(cv2.blur(idata, (3, 3)), dtype=numpy.int16) for axis in [1, 0]: # The sum is purpendicular to the axis of interest impulse = numpy.sqrt(((little-big)**2).sum(axis=2)).sum(axis=axis) #yield scind.median_filter(impulse, 3) yield impulse
def canny(img, lowThreshold): """ Performs canny edge detection on the provided grayscale image. :param img: a grayscale image :param lowThreshold: threshold for the canny operation :return: binary image containing the edges found by canny """ dst = np.zeros(img.shape, dtype=img.dtype) cv2.blur(img, (3, 3), dst) # canny recommends that the high threshold be 3 times the low threshold # the kernel size is 3 as defined above return cv2.Canny(dst, lowThreshold, lowThreshold * 3, dst, 3)
def __init__(self, params, winname, top, bottom): self.top = top self.bottom = bottom top_small = cv2.resize(top, (top.shape[1] / 2, top.shape[0] / 2)) bottom_small = cv2.resize(bottom, (bottom.shape[1] / 2, bottom.shape[0] / 2)) cv2.imshow('top', top_small); cv2.imshow('bottom', bottom_small); extrinsic_filepath = config.PROJPATH + 'extrinsics.yml' intrinsic_filepath = config.PROJPATH + 'intrinsics.yml' self.R = np.asarray(cv2.cv.Load(extrinsic_filepath, name='R')) self.T = np.asarray(cv2.cv.Load(extrinsic_filepath, name='T')) self.R1 = np.asarray(cv2.cv.Load(extrinsic_filepath, name='R1')) self.R2 = np.asarray(cv2.cv.Load(extrinsic_filepath, name='R2')) self.P1 = np.asarray(cv2.cv.Load(extrinsic_filepath, name='P1')) self.P2 = np.asarray(cv2.cv.Load(extrinsic_filepath, name='P2')) self.Q = np.asarray(cv2.cv.Load(extrinsic_filepath, name='Q')) self.M1 = np.asarray(cv2.cv.Load(intrinsic_filepath, name='M1')) self.M2 = np.asarray(cv2.cv.Load(intrinsic_filepath, name='M2')) self.D1 = np.asarray(cv2.cv.Load(intrinsic_filepath, name='D1')) self.D2 = np.asarray(cv2.cv.Load(intrinsic_filepath, name='D2')) self.do_tune = config.TUNE_DISPARITY_MAP R1, R2, P1, P2, self.Q, topValidRoi, bottomValidRoi = cv2.stereoRectify(self.M1, self.D1, self.M2, self.D2, (self.top.shape[1], self.top.shape[0]), self.R, self.T, flags=cv2.CALIB_ZERO_DISPARITY, alpha=-1) top_map1, top_map2 = cv2.initUndistortRectifyMap(self.M1, self.D1, R1, P1, (self.top.shape[1], self.top.shape[0]), cv2.CV_16SC2) bottom_map1, bottom_map2 = cv2.initUndistortRectifyMap(self.M2, self.D2, R2, P2, (self.bottom.shape[1], self.bottom.shape[0]), cv2.CV_16SC2) self.top_r = cv2.remap(self.top, top_map1, top_map2, cv2.cv.CV_INTER_LINEAR); self.bottom_r = cv2.remap(self.bottom, bottom_map1, bottom_map2, cv2.cv.CV_INTER_LINEAR) top_r_small = cv2.resize(self.top_r, (self.top_r.shape[1] / 2, self.top_r.shape[0] / 2)) bottom_r_small = cv2.resize(self.bottom_r, (self.bottom_r.shape[1] / 2, self.bottom_r.shape[0] / 2)) cv2.imshow('top rectified', top_r_small); cv2.imshow('bottom rectified', bottom_r_small); tx1,ty1,tx2,ty2 = topValidRoi bx1,by1,bx2,by2 = bottomValidRoi self.roi = (max(tx1, bx1), max(ty1, by1), min(tx2, bx2), min(ty2, by2)) self.top_r = cv2.blur(self.top_r, (5, 5)) self.bottom_r = cv2.blur(self.bottom_r, (5, 5)) # top_r = cv2.equalizeHist(self.top_r) # bottom_r = cv2.equalizeHist(self.bottom_r) super(SGBMTuner, self).__init__(params, winname)
def circles_iter \ ( frames , blur=None , param1 = None , param2 = None , minFraction = None , maxFraction = None , debug = None ): '''iter<ndarray<y,x,bgr>>[, int][, int][, int][, float][, float][, str] -> iter<...> Locate a circle in each frame. If given, blur with a square kernel `blur` pixels to a side. If given, apply param1 and param2 to cv2.HoughCircles. If given, return circles with diameter between minFraction and maxFraction of the small side of the frame. ''' ns = None for fr in frames: if ns is None: ns = \ ( numpy.empty(fr.shape[:2] + (1,), fr.dtype) , numpy.empty_like(fr) ) det, debug_im = ns # convert to gray; optionally blur cv2.cvtColor(fr, cv2.COLOR_BGR2GRAY, det) cv2.equalizeHist(det, det) if blur is not None: cv2.blur(det, (blur, blur), det) # find circles size = min(fr.shape[:2]) params = {} if param1 is not None: params['param1'] = param1 if param2 is not None: params['param2'] = param2 if minFraction is not None: params['minRadius'] = int(size * minFraction / 2) if maxFraction is not None: params['maxRadius'] = int(size * maxFraction / 2) ret = cv2.HoughCircles(det, cv2.cv.CV_HOUGH_GRADIENT, 1, minDist=size, **params) circles = numpy.empty((0, 3)) if ret is None else ret[0, ...] if debug: numpy.copyto(debug_im, fr) [annot_target(c[0], c[1], c[2], debug_im) for c in circles] cviter._debugWindow(debug, circles_iter.func_name, ns) yield circles
def backgroundRemoval(self, image, background): try: # Blur image and background im_blur = cv2.blur(image, (self.blur, self.blur)) im_bg_blur = cv2.blur(background, (self.blur, self.blur)) # Convert to YCrCb im_YCrCb = cv2.cvtColor(im_blur, cv2.COLOR_BGR2YCR_CB) im_bg_YCrCb = cv2.cvtColor(im_bg_blur, cv2.COLOR_BGR2YCR_CB) # Substract background from image diff = cv2.absdiff(im_YCrCb, im_bg_YCrCb) # Split Y Cr Cb channels channels = cv2.split(diff) # Threshold on each channel y_img = self.thresholding(channels[0], self.th_Y_min, self.th_Y_max) cr_img = self.thresholding(channels[1], self.th_CR_min, self.th_CR_max) cb_img = self.thresholding(channels[2], self.th_CB_min, self.th_CB_max) # Define kernel for morophology edit kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (17, 17)) # Dilate & erode each layer y_img = cv2.erode(cv2.dilate(y_img, kernel), kernel) cr_img = cv2.erode(cv2.dilate(cr_img, kernel), kernel) cb_img = cv2.erode(cv2.dilate(cb_img, kernel), kernel) # Sum channels together sum = cv2.add(y_img, cr_img, cb_img) # Define new kernel for morphology edit #kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (17, 17)) # Dilate & erode sum = cv2.erode(cv2.dilate(sum, kernel), kernel) # Bitwise not sum = cv2.bitwise_not(sum) #total = cv2.merge([y_img, cr_img, cb_img]) #fg = cv2.add(self.im_orig, sum) if self.debugType == 'mask': cv2.imshow('debug', sum) except Exception as detail: print "ERROR: Background removal (", detail, ")" sys.exit(1) return sum
def preprocess(base_path, input_image_path, output_image_path): img = cv2.imread(input_image_path, 0) # Invert the image img = 255 - img ret, thresh = cv2.threshold(img, 120, 255, cv2.THRESH_BINARY) cv2.imwrite(base_path + 'threshold1.jpg', thresh) blur = cv2.blur(thresh, (5, 5)) cv2.imwrite(base_path + 'blur.jpg', blur) kernel = np.ones((5, 5), np.uint8) erosion = cv2.erode(blur, kernel, iterations=1) cv2.imwrite(base_path + 'erosion.jpg', erosion) ret, thresh2 = cv2.threshold(erosion, 12, 255, cv2.THRESH_BINARY) cv2.imwrite(base_path + 'threshold2.jpg', thresh2) kernel = np.ones((3, 2), np.uint8) mask = cv2.dilate(thresh2, kernel, iterations=1) cv2.imwrite(base_path + 'dilate.jpg', mask) rows, cols = mask.shape # cropping # refPt = [] # cropping = True # def click_and_crop(event, x, y, flags, param): # global refPt, cropping # # # if the left mouse button was clicked, record the starting # # (x, y) coordinates and indicate that cropping is being # # performed # if event == cv2.EVENT_LBUTTONDOWN: # refPt = [(x, y)] # cropping = True # # # check to see if the left mouse button was released # elif event == cv2.EVENT_LBUTTONUP: # # record the ending (x, y) coordinates and indicate that # # the cropping operation is finished # refPt.append((x, y)) # cropping = False # # # draw a rectangle around the region of interest # cv2.rectangle(mask, refPt[0], refPt[1], (255, 255, 255), 2) # cv2.namedWindow('image',cv2.WINDOW_NORMAL) # cv2.resizeWindow('image', rows,cols) # cv2.imshow("image", mask) # load the image, clone it, and setup the mouse callback function # clone = mask.copy() cv2.namedWindow("image", cv2.WINDOW_NORMAL) cv2.resizeWindow('image', rows, cols) # cv2.setMouseCallback("image", click_and_crop) # keep looping until the 'q' key is pressed # while True: # # display the image and wait for a keypress # cv2.namedWindow("image" ,cv2.WINDOW_NORMAL) # cv2.resizeWindow('image', rows,cols) # cv2.imshow("image", mask) # key = cv2.waitKey(1) & 0xFF # # # if the 'r' key is pressed, reset the cropping region # if key == ord("r"): # image = clone.copy() # # # if the 'c' key is pressed, break from the loop # elif key == ord("c"): # break # # if there are two reference points, then crop the region of interest from the image and display it # if len(refPt) == 2: # roi = clone[refPt[0][1]:refPt[1][1], refPt[0][0]:refPt[1][0]] cv2.imwrite(output_image_path, mask) cv2.namedWindow("preprocessed_image", cv2.WINDOW_NORMAL) # cv2.resizeWindow('ROI',refPt[0][1]-refPt[1][1], refPt[0][0]-refPt[1][0] ) # cv2.imshow("ROI", mask) # cv2.waitKey(0) cv2.destroyAllWindows()
sigmaColor = 0.3 sigmaSpace = 75 # with m = 1 the input image will not change filter = 'b' # box filter while True: # add noise to image N = np.random.rand(*I.shape) * noise_sigma N=N.astype(np.float32) J = I + N J=J.astype(np.float32) if filter == 'b': K=cv2.blur(J,(m,m)) elif filter == 'g': # filter with a Gaussian filter K=cv2.GaussianBlur(J,(gm,gm),0) elif filter == 'l': # filter with a bilateral filter K=cv2.bilateralFilter(J,size, sigmaColor, sigmaSpace) # filtered image cv2.imshow('demo ', K) key = cv2.waitKey(30) & 0xFF if key == ord('b'): filter = 'b' # box filter print('Box filter')
import cv2 import numpy as np from matplotlib import pyplot as plt img = cv2.imread('images/opencv-logo.png') blur = cv2.blur(img,(5,5)) plt.subplot(121),plt.imshow(img),plt.title('Original') plt.xticks([]), plt.yticks([]) plt.subplot(122),plt.imshow(blur),plt.title('Blurred') plt.xticks([]), plt.yticks([]) plt.show()
ap.add_argument("-i", "--image", required=True, help="Path to the image") # parsing the argument args = vars(ap.parse_args()) # reading the image location through args # and reading the image using cv2.imread image = cv2.imread(args["image"]) cv2.imshow("Original", image) # defining the kernel sizes for the blur operations kernelSizes = [(3, 3), (9, 9), (15, 15)] # displaying the different levels of average blurring with the kernels for (kX, kY) in kernelSizes: blurred = cv2.blur(image, (kX, kY)) cv2.imshow("Average ({},{})".format(kX, kY), blurred) cv2.waitKey(0) # destroying all windows cv2.destroyAllWindows() cv2.imshow("Original", image) # displaying the different levels of gaussian blurring with the kernels for (kX, kY) in kernelSizes: blurred = cv2.GaussianBlur(image, (kX, kY), 0) cv2.imshow("Gaussian ({},{})".format(kX, kY), blurred) cv2.waitKey(0) # destroying all windows cv2.destroyAllWindows()
if out.min() < 0: low_clip = -1. else: low_clip = 0. out = np.clip(out, low_clip, 1.0) out = np.uint8(out * 255) #cv.imshow("gasuss", out) return out gasNoiseImg = gasuss_noise(img, 0.05) #cv2.imshow('noise',gasNoiseImg) #cv2.imwrite('gasNoiseImg.png',gasNoiseImg) #meanfilter dst1 = cv2.blur(spNoiseImg, (3, 3)) dst2 = cv2.blur(spNoiseImg, (5, 5)) dst3 = cv2.blur(spNoiseImg, (7, 7)) dst4 = cv2.blur(gasNoiseImg, (3, 3)) dst5 = cv2.blur(gasNoiseImg, (5, 5)) dst6 = cv2.blur(gasNoiseImg, (7, 7)) dst7 = cv2.medianBlur(spNoiseImg, 3) dst8 = cv2.medianBlur(spNoiseImg, 5) dst9 = cv2.medianBlur(spNoiseImg, 7) dst10 = cv2.medianBlur(gasNoiseImg, 3) dst11 = cv2.medianBlur(gasNoiseImg, 5) dst12 = cv2.medianBlur(gasNoiseImg, 7)
import cv2 from qualipy.utils.focus_measure import * IMAGE = cv2.imread('tests/images/lama.jpg', 0) BLURRED = cv2.blur(IMAGE, (10, 10)) def test_LAPV_returns_less_for_blurred_image(): assert LAPV(BLURRED) < LAPV(IMAGE) def test_LAPM_returns_less_for_blurred_image(): assert LAPM(BLURRED) < LAPM(IMAGE) def test_TENG_returns_less_for_blurred_image(): assert TENG(BLURRED) < TENG(IMAGE) def test_MLOG_returns_less_for_blurred_image(): assert MLOG(BLURRED) < MLOG(IMAGE)
def imageBlur(filename): img = cv.imread(filename) blurImg = cv.blur(img, (20, 20)) return blurImg
def compositeOverlayTopdown(self, base, new, blend_px=21): h, w, d = base.shape #print "h=%d w=%d d=%d" % ( h, w, d) # combine using masks and add operation (assumes pixel # image data will always be at least a little non-zero # create an inverse mask of the current accumulated imagery basegray = cv2.cvtColor(base, cv2.COLOR_BGR2GRAY) ret, base_mask_inv = cv2.threshold(basegray, 1, 255, cv2.THRESH_BINARY_INV) #cv2.imshow('base_mask_inv', base_mask_inv) # create an inverse mask of the new region to be added newgray = cv2.cvtColor(new, cv2.COLOR_BGR2GRAY) ret, new_mask = cv2.threshold(newgray, 1, 255, cv2.THRESH_BINARY_INV) #cv2.imshow('new_mask', new_mask) blendsize = (blend_px, blend_px) kernel = np.ones(blendsize, 'uint8') base_mask_dilate = cv2.dilate(base_mask_inv, kernel) #cv2.imshow('base_mask_dilate', base_mask_dilate) base_mask_blur = cv2.blur(base_mask_dilate, blendsize) #cv2.imshow('base_mask_blur', base_mask_blur) base_mask_blur_inv = 255 - base_mask_blur #cv2.imshow('base_mask_blur_inv', base_mask_blur_inv) base_mask_blur_inv = base_mask_blur_inv | new_mask #cv2.imshow('base_mask_blur_inv2', base_mask_blur_inv) new[:, :, 0] = new[:, :, 0] * (base_mask_blur / 255.0) new[:, :, 1] = new[:, :, 1] * (base_mask_blur / 255.0) new[:, :, 2] = new[:, :, 2] * (base_mask_blur / 255.0) #cv2.imshow('new masked', new) base[:, :, 0] = base[:, :, 0] * (base_mask_blur_inv / 255.0) base[:, :, 1] = base[:, :, 1] * (base_mask_blur_inv / 255.0) base[:, :, 2] = base[:, :, 2] * (base_mask_blur_inv / 255.0) #cv2.imshow('base masked', base) fast = True if fast: # Now clip the new imagery against the area already covered #new = cv2.add(base, new, mask=mask_inv) # And combine ... base = cv2.add(base, new) else: # alpha blend using the mask as the alpha value, works but # is done the hardway because I can't find a native opencv # way to do this. mask_blur = cv2.blur(mask_inv, (50, 50)) for i in xrange(h): for j in xrange(w): #(r0, g0, b0) = base[i][j] #(r1, g1, b1) = new[i][j] #a = mask_blur[i][j] / 255.0 #r = r0*(1.0-a) + r1*a #g = g0*(1.0-a) + g1*a #b = b0*(1.0-a) + b1*a #base = (r, g, b) b = base[i][j] n = new[i][j] a = mask_blur[i][j] / 255.0 if n[0] + n[1] + n[2] > 0: base[i][j][0] = b[0] * (1.0 - a) + n[0] * a base[i][j][1] = b[1] * (1.0 - a) + n[1] * a base[i][j][2] = b[2] * (1.0 - a) + n[2] * a #cv2.imshow('base', base) #cv2.waitKey() return base
# Starting with 100's to prevent error while masking h,s,v = 100,100,100 def nothing(x): pass # Creating track bar cv2.createTrackbar('h', 'HSV_TrackBar',0,179,nothing) cv2.createTrackbar('s', 'HSV_TrackBar',0,255,nothing) cv2.createTrackbar('v', 'HSV_TrackBar',0,255,nothing) # Real Code_Starts_Here while(1): start_time = time.time() ret, frame = cam.read() #capture frames from the camera blur = cv2.blur(frame,(3,3)) #Blur the image hsv = cv2.cvtColor(blur,cv2.COLOR_BGR2HSV) #Convert to HSV color space #Create a binary image with where white will be skin colors and rest is black mask2 = cv2.inRange(hsv,np.array([2,50,50]),np.array([15,255,255])) #Kernel matrices for morphological transformation kernel_square = np.ones((11,11),np.uint8) kernel_ellipse= cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(5,5)) #Perform morphological transformations to filter out the background noise #Dilation increase skin color area #Erosion increase skin color area dilation = cv2.dilate(mask2,kernel_ellipse,iterations = 1) erosion = cv2.erode(dilation,kernel_square,iterations = 1) dilation2 = cv2.dilate(erosion,kernel_ellipse,iterations = 1)
cap = cv.VideoCapture(0) #cv.namedWindow('Trackbar',cv.WINDOW_AUTOSIZE) cv.createTrackbar('B', 'Trackbar', 0, 255, nothing) cv.createTrackbar('W', 'Trackbar', 0, 255, nothing) while (True): # Capture frame-by-frame ret, frame = cap.read() B = cv.getTrackbarPos('B', 'Trackbar') W = cv.getTrackbarPos('W', 'Trackbar') # Our operations on the frame come here gray = cv.cvtColor(frame, cv.COLOR_BGR2GRAY) blur = cv.blur(gray, (2, 2)) _, thres = cv.threshold(blur, 170, 255, cv.THRESH_BINARY_INV) # cnt = contours(thres,frame) _, contours, _ = cv.findContours(thres, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE) lines = cv.HoughLinesP(thres, 1, np.pi / 180, 100, 150, 150) #print(lines.shape) leftmost = 0 rightmost = 0 topmost = 0 bottommost = 0 for i in range(0, len(contours)):
fmask = cv2.threshold(fmask, 10, 255, 0)[1] ####### Morphological Processing ######### fmask = cv2.erode(fmask, cv2.getStructuringElement(cv2.MORPH_ERODE, (2, 2)), iterations=2) mask1=cv2.morphologyEx(fmask,cv2.MORPH_CLOSE,\ cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(4,4))) mask1 = cv2.erode(mask1, cv2.getStructuringElement(cv2.MORPH_ERODE, (2, 2)), iterations=2) #cv2.imshow('mask1',mask1); fg_frame = cv2.bitwise_and(roi, roi, mask=mask1) #cv2.imshow('fg_frame',fg_frame); gr_frame = cv2.cvtColor(fg_frame, cv2.COLOR_BGR2GRAY) gr_frame = cv2.blur(gr_frame, (10, 10)) bw_frame = cv2.threshold(gr_frame, 50, 255, 0)[1] ############ Tracking contour tangan ################ con = cv2.findContours(bw_frame, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[0] try: my_con = max(con, key=cv2.contourArea) except: my_con = np.array([[[1, 0], [1, 2], [2, 3]]], dtype=np.int32) #pass; try: if cv2.contourArea(my_con) > 90: hull = cv2.convexHull(my_con, True)
def process_image(self, frame): grey = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) blur = cv2.blur(grey, (7, 7)) edges = cv2.Canny(blur, 15.0, 30.0) return edges
count = 1935 for i in range(121): img = cv2.imread(path + folder + '/' + str(i) + '.jpg') gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) for i in range(5): thresh_value = i * 20 ret1, th1 = cv2.threshold(gray_img, 100 + thresh_value, 255, cv2.THRESH_BINARY) count += 1 cv2.imwrite(path + folder + '/' + str(count) + '.jpg', th1) ret2, th2 = cv2.threshold(gray_img, 100 + thresh_value, 255, cv2.THRESH_OTSU) count += 1 cv2.imwrite(path + folder + '/' + str(count) + '.jpg', th2) #Filter variation (Blur and sharpen) for folder in os.listdir(path): count = 3145 for i in range(121): img = cv2.imread(path + folder + '/' + str(i) + '.jpg') gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) for i in range(2, 10, 2): ksize = (i, i) blurredimg = cv2.blur(gray_img, ksize) count += 1 cv2.imwrite(path + folder + '/' + str(count) + '.jpg', blurredimg) for i in range(9, 12, 1): kernel = np.array([[-1, -1, -1], [-1, i, -1], [-1, -1, -1]]) sharpen = cv2.filter2D(gray_img, -1, kernel) count += 1 cv2.imwrite(path + folder + '/' + str(count) + '.jpg', sharpen)
def trackingthread(argv): global positions global calibrated global fs global transform global transform_size process_arguments(argv) # The size of the board in inches, measured between the two # robot boundaries: board_size = [16, 16] # Number of pixels to display per inch in the final transformed image. This # was selected somewhat arbitrarily (I chose 17 because it fit on my screen): dpi = 17 transform_size = (int(board_size[0] * dpi), int(board_size[1] * dpi)) cap = open_camera(camera_id) # Calculate the perspective transform matrix transform = get_transform_matrix(cap, board_size, dpi, 'calibrations.txt') # saturation ranges for targeting desired colour sat1 = 70 sat2 = 40 sat_range = 20 cv2.namedWindow('frame', cv2.CV_WINDOW_AUTOSIZE) snake_rectangle_list = [] snake_centroid_list = [] show_rectangle = True show_centroid = True # can take a while for camera to focus on first use # code below allows for a 2 second delay frame = get_frame(cap) sleep(1) frame = get_frame(cap) sleep(1) while (1): # read the frame frame = get_frame(cap) frame_no_blur = frame.copy() # smooth it frame = cv2.blur(frame, (3, 3)) # shows frame without drawings or edits #cv2.imshow('frame2',frame) # two-point colour tracking # convert to hsv and find range of colors hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) thresh_origin, thresh_direction = get_thresholds( hsv, sat1, sat2, sat_range) #cv2.imshow('dire',thresh_direction) cx_origin, cy_origin = find_centroid(thresh_origin, frame) cx_direction, cy_direction = find_centroid(thresh_direction, frame) if show_centroid: if cx_origin is not None and cx_direction is not None: # finding centroids of best_cnt and draw a circle there cv2.circle(frame, (cx_origin, cy_origin), 5, 255, -1) cv2.circle(frame, (cx_direction, cy_direction), 5, 255, -1) # draw line draw_directed_line(frame_no_blur, cx_origin, cy_origin, cx_direction, cy_direction) # calibrate if not calibrated and (cx_origin, cy_origin) != (0, 0): set_calibration(cx_origin, cy_origin) calibrated = True if cx_origin is not None and cx_direction is not None: # work out current angle angle = calculate_angle(cx_origin, cy_origin, cx_direction, cy_direction) # add position to list add_position((get_elapsedtime(), cx_origin, cy_origin, angle, cx_direction, cy_direction)) # draw path, the last 100 positions #draw_path(frame) # print position details draw_text(frame_no_blur, (get_elapsedtime(), cx_origin, cy_origin, angle, cx_direction, cy_direction)) # display current frame cv2.imshow('frame', frame_no_blur) # Show it, if key pressed is 'Esc', exit the loop k = cv2.waitKey(1) #print k if k == 27: # esc break elif k == 114: # r reset_calibration() elif k == 97: # a sat1 += 5 elif k == 122: # z sat1 -= 5 elif k == 115: # s sat2 += 5 elif k == 120: # x sat2 -= 5 # print str(sat1) + ', ' + str(sat2) # Clean up everything before leaving cleanup(cap) # Log positions to file write_positions_to_file()
def randomBlur(self, bgr): if random.random() < 0.5: bgr = cv2.blur(bgr, (5, 5)) return bgr
def graycode_analysis(screen_list, path): print('------------------------') print('Analyse Graycode Pattern') print('------------------------') # load configuration filename = path + 'graycode_config.json' with open(filename, 'r') as f: config = json.load(f) img_HW = config['camera']['height'], config['camera']['width'] N = config['num_projectors'] proj_whole_HW = config['projector_whole_HW'] proj_x_stack, proj_y_stack = [], [] azimuth_stack, polar_stack = [], [] overlap_x, overlap_y = [], [] overlap_weight = [] p = util.Propeller() for n in range(N): print('----- %d/%d -----' % (n + 1, N)) proj_id = n + 1 config_sub = config['parameters']['projector_%d' % proj_id] proj_HW = config_sub['y_num_pixel'], config_sub['x_num_pixel'] x_starting = config_sub['x_starting'] y_starting = config_sub['y_starting'] scr = screen_list[n] i1, i2, j1, j2 = scr.get_evaluation_area_index() print('Decoding Gray-code pattern...', end='') p.start() # reference image if not (config_sub['xgraycode_PN'] and config_sub['ygraycode_PN']): filename = path + 'gray_proj%d_grey.jpg' % proj_id img_ref = imread(filename) img_ref = shift_horizontal(img_ref, scr.horizontal_shift) img_ref = add_equirectangular_margin(img_ref, margin[1], margin[0]) img_ref = img_ref[i1:i2, j1:j2, :] # ----- x-axis ----- BGR = config_sub['xgraycode_BGR'] PN = config_sub['xgraycode_PN'] num_imgs = config_sub['xgraycode_num_image'] nbits = config_sub['xgraycode_num_bits'] offset = config_sub['xgraycode_offset'] imgs_code = np.empty([i2 - i1, j2 - j1, nbits], dtype=np.bool) for i in range(num_imgs): # load image filename = path + 'gray_proj%d_x%d_posi.jpg' % (proj_id, i) img = imread(filename) img = shift_horizontal(img, scr.horizontal_shift) img = add_equirectangular_margin(img, margin[1], margin[0]) img = img[i1:i2, j1:j2, :] if PN == True: filename = path + 'gray_proj%d_x%d_nega.jpg' % (proj_id, i) img_nega = imread(filename) img_nega = shift_horizontal(img_nega, scr.horizontal_shift) img_nega = add_equirectangular_margin(img_nega, margin[1], margin[0]) img_nega = img_nega[i1:i2, j1:j2, :] # judge 0 or 1 if BGR: if PN == False: code = (img > img_ref) else: code = (img > img_nega) for j in range(3): if (3 * i + j) >= nbits: break imgs_code[:, :, 3 * i + j] = code[:, :, j] else: if PN == False: code = (img[:, :, 1] > img_ref[:, :, 1]) # green layer else: code = (img[:, :, 1] > img_nega[:, :, 1]) imgs_code[:, :, i] = code # decode imgs_bin = np.empty_like(imgs_code, dtype=np.bool) imgs_bin[:, :, 0] = imgs_code[:, :, 0] for i in range(1, nbits): imgs_bin[:, :, i] = np.logical_xor(imgs_bin[:, :, i - 1], imgs_code[:, :, i]) weight = 2**np.arange(nbits)[::-1].reshape(1, 1, -1) proj_x = np.sum(imgs_bin * weight, axis=-1).astype(np.float32) proj_x += x_starting - offset # ----- y-axis ----- BGR = config_sub['ygraycode_BGR'] PN = config_sub['ygraycode_PN'] num_imgs = config_sub['ygraycode_num_image'] nbits = config_sub['ygraycode_num_bits'] offset = config_sub['ygraycode_offset'] imgs_code = np.empty([i2 - i1, j2 - j1, nbits], dtype=np.bool) for i in range(num_imgs): # load image filename = path + 'gray_proj%d_y%d_posi.jpg' % (proj_id, i) img = imread(filename) img = shift_horizontal(img, scr.horizontal_shift) img = add_equirectangular_margin(img, margin[1], margin[0]) img = img[i1:i2, j1:j2, :] if PN == True: filename = path + 'gray_proj%d_y%d_nega.jpg' % (proj_id, i) img_nega = imread(filename) img_nega = shift_horizontal(img_nega, scr.horizontal_shift) img_nega = add_equirectangular_margin(img_nega, margin[1], margin[0]) img_nega = img_nega[i1:i2, j1:j2, :] # judge 0 or 1 if BGR: if PN == False: code = (img > img_ref) else: code = (img > img_nega) for j in range(3): if (3 * i + j) >= nbits: break imgs_code[:, :, 3 * i + j] = code[:, :, j] else: if PN == False: code = (img[:, :, 1] > img_ref[:, :, 1]) # green layer else: code = (img[:, :, 1] > img_nega[:, :, 1]) imgs_code[:, :, i] = code # decode imgs_bin = np.empty_like(imgs_code, dtype=np.bool) imgs_bin[:, :, 0] = imgs_code[:, :, 0] for i in range(1, nbits): imgs_bin[:, :, i] = np.logical_xor(imgs_bin[:, :, i - 1], imgs_code[:, :, i]) weight = 2**np.arange(nbits)[::-1].reshape(1, 1, -1) proj_y = np.sum(imgs_bin * weight, axis=-1).astype(np.float32) proj_y += y_starting - offset # remove pulse noise from bit errors proj_x = cv2.medianBlur(proj_x, KSIZE_MEDIAN_FILTER) proj_y = cv2.medianBlur(proj_y, KSIZE_MEDIAN_FILTER) # smoothing proj_x = cv2.blur(proj_x, (KSIZE_SMOOTHING_X, KSIZE_SMOOTHING_Y)) proj_y = cv2.blur(proj_y, (KSIZE_SMOOTHING_X, KSIZE_SMOOTHING_Y)) plt.subplot(211) plt.imshow(proj_x, cmap=plt.cm.jet) plt.subplot(212) plt.imshow(proj_y, cmap=plt.cm.jet) plt.savefig(path + 'plt_decode_%d.pdf' % proj_id) plt.close() # pixel direction polar, azimuth = scr.get_direction_meshgrid() # index_masker = scr.get_masked_index() proj_x_sample = proj_x[index_masker] proj_y_sample = proj_y[index_masker] polar_sample = polar[index_masker] azimuth_sample = azimuth[index_masker] points_sample = np.c_[proj_x_sample, proj_y_sample] proj_x = proj_x[np.where((x_starting <= proj_x) & (proj_x <= (x_starting + proj_HW[1])))] proj_y = proj_y[np.where((y_starting <= proj_y) & (proj_y <= (y_starting + proj_HW[0])))] p.end() # interpolate points candidate print('Refining projector pixel...', end='') p.start() x1 = int(np.ceil(proj_x_sample.min())) x2 = int(proj_x_sample.max()) y1 = int(np.ceil(proj_y_sample.min())) y2 = int(proj_y_sample.max()) proj_y_interp_cand, proj_x_interp_cand = np.mgrid[y1:y2, x1:x2] points_interp_cand = np.c_[proj_x_interp_cand.reshape(-1), proj_y_interp_cand.reshape(-1)] # determine interpolate points n_poly = 100 # ポリゴン数(超大まかな目安) k = int(2 * (np.sqrt(len(points_sample)) / (n_poly / 4))**2 * np.pi) hull = concavehull.concavehull(points_sample, k) inside = concavehull.check_inside(points_interp_cand, hull) i_inside_hull = np.where(inside)[0] points_interp = points_interp_cand[i_inside_hull, :] p.end() # interpolation print('Estimating pixel direction...', end='') p.start() f = LinearNDInterpolator(points_sample, polar_sample) polar_interp = f(points_interp) f = LinearNDInterpolator(points_sample, azimuth_sample) azimuth_interp = f(points_interp) i_inside_area = np.where((scr.area_polar[0] <= polar_interp) & (polar_interp <= scr.area_polar[1]) & (scr.area_azimuth[0] <= azimuth_interp) & (azimuth_interp <= scr.area_azimuth[1]))[0] proj_x_stack.append(points_interp[i_inside_area, 0]) proj_y_stack.append(points_interp[i_inside_area, 1]) azimuth_stack.append(azimuth_interp[i_inside_area]) polar_stack.append(polar_interp[i_inside_area]) # overlap weighting if scr.overlap_angle >= 0: left_side, right_side = scr.area_azimuth left_ovlp_end = left_side + scr.overlap_angle right_ovlp_end = right_side - scr.overlap_angle i_ovlp_left = np.where((left_side <= azimuth_stack[n]) & (azimuth_stack[n] < left_ovlp_end))[0] overlap_x.append(proj_x_stack[n][i_ovlp_left]) overlap_y.append(proj_y_stack[n][i_ovlp_left]) azim_ovlp = azimuth_stack[n][i_ovlp_left] weight = (azim_ovlp - left_side) / (left_ovlp_end - left_side) overlap_weight.append(weight) i_ovlp_right = np.where((right_ovlp_end < azimuth_stack[n]) & (azimuth_stack[n] <= right_side))[0] overlap_x.append(proj_x_stack[n][i_ovlp_right]) overlap_y.append(proj_y_stack[n][i_ovlp_right]) azim_ovlp = azimuth_stack[n][i_ovlp_right] weight = (azim_ovlp - right_side) / (right_ovlp_end - right_side) overlap_weight.append(weight) else: overlap_x.append([]) overlap_y.append([]) overlap_weight.append([]) # cancel horizontal shift azimuth_stack[n] -= scr.horizontal_shift_deg p.end() proj_x_stack = np.hstack(proj_x_stack).astype(np.int) proj_y_stack = np.hstack(proj_y_stack).astype(np.int) azimuth_stack = np.hstack(azimuth_stack) polar_stack = np.hstack(polar_stack) overlap_x = np.hstack(overlap_x).astype(np.int) overlap_y = np.hstack(overlap_y).astype(np.int) overlap_weight = np.hstack(overlap_weight) overlap_tone_input = scr.tone_input overlap_tone_output = scr.tone_output mapper = (proj_x_stack, proj_y_stack, polar_stack, azimuth_stack, overlap_x, overlap_y, overlap_weight, overlap_tone_input, overlap_tone_output, np.array(proj_whole_HW)) return mapper
return count else: return 1 cap = cv2.VideoCapture('C:/Users/herom/Videos/AKIRA 金田と鉄雄の対決-Vk_AuM6ozks.mp4') ret, frame = cap.read() #画像サイズを求める。 height, width = frame.shape[:2] print(height) print(width) while (cap.isOpened()): ret, frame = cap.read() #ブラーをかけてノイズを飛ばす。 blur = cv2.blur(frame, (3, 3)) # グレースケース化 gray = cv2.cvtColor(blur, cv2.COLOR_BGR2GRAY) #CannyにてEdge取り出し。 edges = cv2.Canny(gray, Edge_min, Edge_max) #二値化 ret, thresh2 = cv2.threshold(edges, 127, 255, cv2.THRESH_BINARY) #output_image output = thresh2 #輪郭の取り出し contours, hierarchy = cv2.findContours(thresh2, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
while(True): # Capture frame-by-frame ret, frame = cap.read() if ret: frame = resize_frame(frame) orig = frame bw_frame = cv.cvtColor(frame,cv.COLOR_RGB2GRAY) high_thresh, thresh_im = cv.threshold((bw_frame), 0, 255, cv.THRESH_BINARY + cv.THRESH_OTSU) # cv.imshow('thres',thresh_im) lowThresh = 0.5*high_thresh # print(high_thresh, lowThresh) R,G,B = cv.split(frame) # smooth = cv.bilateralFilter(frame,10,25,51) smooth = cv.blur(frame,(2,2)) # cv.imshow('test',smooth) # GENERATE CANNY EDGES canny = cv.Canny(smooth, 100, high_thresh) sigma = 0.6 v = np.median(smooth) lower = int(max(0, (1.0 - sigma) * v)) upper = int(min(255, (1.0 + sigma) * v)) # print(lower, upper) # canny = cv.Canny(smooth, lower, upper) #TODO: ADD TO RET FRAMES # cv.imshow('canny_new',canny) ## FIND CONTOURS
parser.add_argument('--option2') args = parser.parse_args() ##### 读取图片 ############# img_name = os.path.split(args.img)[-1] img_name, ext = os.path.splitext(img_name) input = cv.imread(args.img, flags=cv.IMREAD_COLOR) temp = input ######处理模块########### #图像扰动 if args.mode: commands = ['blur', 'rotate', 'light', 'scale', 'shift'] assert (args.mode in commands) if args.mode == 'blur': if args.option1: input = cv.blur( input, (int(args.option1), int(args.option1))) #具体模糊参数需要改代码 img_name = img_name + "_blur_" + args.option1 else: input = cv.blur(input, (5, 5)) img_name = img_name + "_blur_5" elif args.mode == 'rotate': h, w = input.shape[:2] # 宽高 center = (w // 2, h // 2) # 旋转中心 if args.option1: R_M = cv.getRotationMatrix2D( center, float(args.option1), 1.0 ) #生成旋转矩阵 参数1 表示旋转中心,2 表示旋转角度 (从逆时针开始) 3表示旋转后的大小 1表示和原图相同 print(R_M) img_name = img_name + "_rotate_" + args.option1 else:
def stgcn_visualize(pose, edge, feature, video, label=None, label_sequence=None, height=1080): _, T, V, M = pose.shape T = len(video) pos_track = [None] * M for t in range(T): frame = video[t] # image resize H, W, c = frame.shape frame = cv2.resize(frame, (height * W // H //2 , height//2)) H, W, c = frame.shape scale_factor = 2 * height / 1080 # draw skeleton skeleton = frame * 0 text = frame * 0 for m in range(M): score = pose[2, t, :, m].mean() if score < 0.3: continue for i, j in edge: xi = pose[0, t, i, m] yi = pose[1, t, i, m] xj = pose[0, t, j, m] yj = pose[1, t, j, m] if xi + yi == 0 or xj + yj == 0: continue else: xi = int((xi + 0.5) * W) yi = int((yi + 0.5) * H) xj = int((xj + 0.5) * W) yj = int((yj + 0.5) * H) cv2.line(skeleton, (xi, yi), (xj, yj), (255, 255, 255), int(np.ceil(2 * scale_factor))) body_label = label_sequence[t // 4][m] x_nose = int((pose[0, t, 0, m] + 0.5) * W) y_nose = int((pose[1, t, 0, m] + 0.5) * H) x_neck = int((pose[0, t, 1, m] + 0.5) * W) y_neck = int((pose[1, t, 1, m] + 0.5) * H) half_head = int(((x_neck - x_nose)**2 + (y_neck - y_nose)**2)**0.5) pos = (x_nose + half_head, y_nose - half_head) if pos_track[m] is None: pos_track[m] = pos else: new_x = int(pos_track[m][0] + (pos[0] - pos_track[m][0]) * 0.2) new_y = int(pos_track[m][1] + (pos[1] - pos_track[m][1]) * 0.2) pos_track[m] = (new_x, new_y) cv2.putText(text, body_label, pos_track[m], cv2.FONT_HERSHEY_TRIPLEX, 0.5 * scale_factor, (255, 255, 255)) # generate mask mask = frame * 0 feature = np.abs(feature) feature = feature / feature.mean() for m in range(M): score = pose[2, t, :, m].mean() if score < 0.3: continue f = feature[t // 4, :, m]**5 if f.mean() != 0: f = f / f.mean() for v in range(V): x = pose[0, t, v, m] y = pose[1, t, v, m] if x + y == 0: continue else: x = int((x + 0.5) * W) y = int((y + 0.5) * H) cv2.circle(mask, (x, y), 0, (255, 255, 255), int(np.ceil(f[v]**0.5 * 8 * scale_factor))) blurred_mask = cv2.blur(mask, (12, 12)) skeleton_result = blurred_mask.astype(float) * 0.75 skeleton_result += skeleton.astype(float) * 0.25 skeleton_result += text.astype(float) skeleton_result[skeleton_result > 255] = 255 skeleton_result.astype(np.uint8) rgb_result = blurred_mask.astype(float) * 0.75 rgb_result += frame.astype(float) * 0.5 rgb_result += skeleton.astype(float) * 0.25 rgb_result[rgb_result > 255] = 255 rgb_result.astype(np.uint8) put_text(skeleton, 'inputs of st-gcn', (0.1, 0.5)) text_1 = cv2.imread('./resource/demo_asset/original_video.png', cv2.IMREAD_UNCHANGED) text_2 = cv2.imread('./resource/demo_asset/pose_estimation.png', cv2.IMREAD_UNCHANGED) text_3 = cv2.imread('./resource/demo_asset/attention+prediction.png', cv2.IMREAD_UNCHANGED) text_4 = cv2.imread('./resource/demo_asset/attention+rgb.png', cv2.IMREAD_UNCHANGED) blend(frame, text_1) blend(skeleton, text_2) blend(skeleton_result, text_3) blend(rgb_result, text_4) if label is not None: label_name = 'voting result: ' + label put_text(skeleton_result, label_name, (0.1, 0.5)) img0 = np.concatenate((frame, skeleton), axis=1) img1 = np.concatenate((skeleton_result, rgb_result), axis=1) img = np.concatenate((img0, img1), axis=0) yield img
cv2.rectangle(img, (0,int(img.shape[1]*0.3) ), (int(img.shape[0]*0.5),img.shape[1]), (255,0,0),2) crop_img = img[int(img.shape[1]*0.3)+aBor:img.shape[0]-aBor, aBor:int(img.shape[0]*0.5)-aBor] if (bGuardar): #guarda la imagen de fondo cv2.imwrite( 'fondo_box1.png',crop_img) bGuardar=False #lee el fondo de la imagen fondo_box1 = cv2.imread('fondo_box1.png') #restamos la imagen con el fondo resta = cv2.subtract(fondo_box1,crop_img) #diferencia comun #resta = cv2.absdiff (fondo_box1,crop_img) #diferencia absoluta # filtro de desenfoque resta = cv2.blur(resta,(5,5)) # convert to grayscale grey = cv2.cvtColor(resta, cv2.COLOR_BGR2GRAY) # applying gaussian blur value = (15, 15) blurred = cv2.GaussianBlur(grey, value, 0) # thresholdin: Otsu's Binarization method _, thresh1 = cv2.threshold(blurred, 35, 255, cv2.THRESH_BINARY+cv2.THRESH_OTSU) # check OpenCV version to avoid unpacking error (version, _, _) = cv2.__version__.split('.') if version == '3':
import numpy as np import cv2 from matplotlib import pyplot as plt #greyscale img=cv2.imread('DeepakKanuri.jpg',0) #img=cv2.cvtColor(img,cv2.COLOR_BGR2RGB) img1=cv2.imread('DeepakKanuri.jpg',1) #img1=cv2.cvtColor(img1,cv2.COLOR_BGR2RGB) cv2.imwrite('Deepak.png',img) plt.imshow(img) plt.show() rows,cols = img.shape #blur blur=cv2.blur(img1,(20,20)) cv2.imwrite('blur.png',blur) blur=cv2.blur(img,(20,20)) cv2.imwrite('blur1.png',blur) #translated trans = np.float32([[1,0,500],[0,1,100]]) transim = cv2.warpAffine(img,trans,(cols,rows)) cv2.imwrite('translatedimage.png',transim) trans = np.float32([[1,0,500],[0,1,100]]) transim = cv2.warpAffine(img1,trans,(cols,rows)) cv2.imwrite('translatedimage1.png',transim) #rotated rotate = cv2.getRotationMatrix2D((cols/2,rows/2),180,1) rotateim = cv2.warpAffine(img,rotate,(cols,rows))
def blur(img, kernel_size=3): return cv2.blur(img, (kernel_size, kernel_size))
def test_img(img_name): img = cv2.imread(img_name, cv2.IMREAD_GRAYSCALE) img_start = cv2.imread(img_name) white_black(img_name, "res2.jpg", 0.85) img = cv2.imread("res2.jpg", cv2.IMREAD_GRAYSCALE) blur = cv2.blur(img, (3, 3)) # blur the image ret, thresh = cv2.threshold(blur, 50, 255, cv2.THRESH_BINARY) contours, hierarchy = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) hull = [] # calculate points for each contour for i in range(len(contours)): hull.append(cv2.convexHull(contours[i], False)) drawing = np.zeros((thresh.shape[0], thresh.shape[1], 3), np.uint8) canvas = np.ones((img.shape[0], img.shape[1], 3), np.uint8) * 100 for i in range(len(contours)): color_contours = (0, 255, 0) #color = (255, 0, 0) cv2.drawContours(drawing, contours, i, color_contours, 1, 8, hierarchy) #cv2.drawContours(canvas, hull, i, color, 1, 8) cv2.imshow('img1', img) cv2.waitKey(0) cv2.imshow('countur', drawing) cv2.waitKey(0) # Проходя через все контуры, найденные на изображении. font = cv2.FONT_HERSHEY_COMPLEX page = [] rotrect = cv2.minAreaRect(contours[0]) for cnt in contours: if cv2.arcLength(cnt, True) > 800: approx = cv2.approxPolyDP(cnt, 0.012 * cv2.arcLength(cnt, True), True) cv2.drawContours(canvas, [approx], 0, (0, 0, 255), 5) n = approx.ravel() i = 0 for j in n: if (i % 2 == 0): help_arr = [n[i], n[i + 1]] page.append(help_arr) x = n[i] y = n[i + 1] string = str(x) + " " + str(y) cv2.putText(canvas, string, (x, y), font, 0.5, (0, 255, 0)) i = i + 1 rotrect = cv2.minAreaRect(cnt) # РЕДАГУВАННЯ МАСИВУ ДЛЯ ВІДПОВІДНОСТІ # тут треба повороти # коробочка по фрейду box = cv2.boxPoints(rotrect) box = np.int0(box) cv2.drawContours(canvas, [box], 0, (0, 255, 255), 2) cv2.imshow('box', canvas) cv2.waitKey(0) # матриця переходу і трансформація (x1, y1), (x2, y2), angle = rotrect box1 = [[0, 0], [0, y2], [x2, y2], [x2, 0]] box1 = forvard_back(box1) box1 = max_X_sort(box1) box = np.array(box, np.float32) box1 = np.array(box1, np.float32) page = aprox_in_array(find_near(page, box), page) page = np.array(page, np.float32) matrix = cv2.getPerspectiveTransform(page, box1) result = cv2.warpPerspective(img_start, matrix, (int(x2), int(y2))) # Wrap the transformed image cv2.imshow('img transform', result) cv2.imwrite("res.jpg", result) cv2.waitKey(0) # висвітлення фону паперу, приберання малих косяків та підведення ліній # increasing the contrast 20% image = Image.open("res.jpg") new_image = ImageEnhance.Contrast(image).enhance(1.2) result = np.array(new_image) cv2.imwrite("res.jpg", result) white_black("res.jpg", "res2.jpg", 0.85) result = cv2.imread("res2.jpg") cv2.imshow('bw-result', result) cv2.waitKey(0) cv2.destroyAllWindows() # thickness gray = cv2.cvtColor(result, cv2.COLOR_BGR2GRAY) gray = cv2.bitwise_not(gray) cv2.imshow('gray invert', gray) cv2.waitKey(0) edges = cv2.Canny(result, 50, 150, apertureSize=3) minLineLength = 1 maxLineGap = 1 lines = cv2.HoughLinesP(edges, 1, np.pi / 180, 20, minLineLength, maxLineGap) for l in lines: for x1, y1, x2, y2 in l: cv2.line(result, (x1, y1), (x2, y2), (0, 0, 0), 1) cv2.imshow('with countur', result) cv2.waitKey(0) cv2.destroyAllWindows()
# read the input image img_base = cv2.imread("./images/basic_base.png") img_rotated = cv2.imread("./images/basic_rot45.png") # ********************************* # * * # * Detects Circles in Images * # * * # ********************************* img = cv2.imread("./images/basic_base.png", cv2.IMREAD_COLOR) gray = cv2.cvtColor(img_base, cv2.COLOR_BGR2GRAY) output = img.copy() # Blur using 3 * 3 kernel. gray_blurred = cv2.blur(gray, (3, 3)) # Apply Hough transform on the blurred image. detected_circles = cv2.HoughCircles(gray_blurred, cv2.HOUGH_GRADIENT, 1, 20, param1=50, param2=30, minRadius=200, maxRadius=220) max_pt = [0, 0, 0] # Draw circles that are detected. if detected_circles is not None:
def test(): """ kerasを使わずにデータ数を増やす 参考 https://qiita.com/bohemian916/items/9630661cd5292240f8c7 """ input_dir = "data/input/gucky/" # "data/input/gucky/" filelist = os.listdir(input_dir) output_dir = "data/input/gucky_generate_manual/" # "data/input/gucky_generate/" make_dir(output_dir) # コントラスト調整 min_table = 50 max_table = 205 diff_table = max_table - min_table # 165 LUT_HC = np.arange(256, dtype='uint8') LUT_LC = np.arange(256, dtype='uint8') # ハイコントラストLUT作成 for i in range(0, min_table): LUT_HC[i] = 0 for i in range(min_table, max_table): LUT_HC[i] = 255 * (i - min_table) / diff_table for i in range(max_table, 255): LUT_HC[i] = 255 # ローコントラストLUT作成 for i in range(256): LUT_LC[i] = min_table + i * (diff_table) / 255 # 平滑化 average_squeare = (10, 10) # ガウシアン分布によるノイズ mean, sigma = 0, 10 # Salt&Pepperノイズ s_vs_p = 0.5 amount = 0.004 for i, file in enumerate(filelist): img = cv2.imread(input_dir + file) # numpy配列で取得 (128, 128, 3) row, col, ch = img.shape filename = os.path.splitext(file)[0] high_cont_img = cv2.LUT(img, LUT_HC) # ハイコントラスト cv2.imwrite(output_dir + filename + "_LUT_HC" + ".jpg", high_cont_img) low_cont_img = cv2.LUT(img, LUT_LC) # ローコントラスト cv2.imwrite(output_dir + filename + "_LUT_LC" + ".jpg", low_cont_img) blur_img = cv2.blur(img, average_squeare) # 平滑化 cv2.imwrite(output_dir + filename + "_blur" + ".jpg", blur_img) gauss = np.random.normal(mean, sigma, (row, col, ch)) # (128, 128, 3) gauss = gauss.reshape(row, col, ch) # reshapeする必要 gauss_img = img + gauss # ガウシアン分布のノイズ cv2.imwrite(output_dir + filename + "_gauss" + ".jpg", gauss_img) # 塩モード sp_img = img.copy() num_salt = np.ceil(amount * img.size * s_vs_p) coords = [ np.random.randint(0, i - 1, int(num_salt)) for i in img.shape ] sp_img[coords[:-1]] = (255, 255, 255) # 胡椒モード num_pepper = np.ceil(amount * img.size * (1. - s_vs_p)) coords = [ np.random.randint(0, i - 1, int(num_pepper)) for i in img.shape ] sp_img[coords[:-1]] = (0, 0, 0) cv2.imwrite(output_dir + filename + "_salt_pepper" + ".jpg", sp_img) # 反転 pass # 拡大・縮小 pass
img = cv.imread('imgs/lenna.png') w, h = int(img.shape[1] * 0.5), int(img.shape[0] * 0.5) img = cv.resize(img, (w, h)) # cv.imshow('img', img) rgb = cv.cvtColor(img, cv.COLOR_BGR2RGB) kernel = np.ones((5, 5), np.uint8) / 25 # homogenous 2D convolution using custom kernel conv2D = cv.filter2D(rgb, -1, kernel) # cv.imshow('2D conv', cv.cvtColor(conv2D, cv.COLOR_RGB2BGR)) # NB: boxFilter ==> blur ==> filter2D can be used interchangeabl # average smoothing avg = cv.blur(rgb, (5, 5)) # cv.imshow('avg smoothing', avg) # gaussian smoothing gaussian_img = cv.GaussianBlur(rgb, (3, 3), 0) # cv.imshow('Gaussian blur', gaussian_img) # median smoothing -- for removing salt/pepper noise median_img = cv.medianBlur(rgb, 3) # cv.imshow('median blur', median_img) # bilateral smoothing -- preserve edges and borders while removing noises bilateral = cv.bilateralFilter(rgb, 20, 30, 40) # cv.imshow('bilateral', bilateral) titles = ['orig', '2D Conv', 'blur', 'gaussian', 'median', 'bilateral']
def blur(img): return (cv2.blur(img, (5, 5)))
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) cv2.imshow("Grey", gray) #转化为高水平梯度和低竖直梯度 gradX = cv2.Sobel(gray, ddepth=cv2.CV_32F, dx=1, dy=0, ksize=-1) gradY = cv2.Sobel(gray, ddepth=cv2.CV_32F, dx=0, dy=1, ksize=-1) # subtract the y-gradient from the x-gradient gradient = cv2.subtract(gradX, gradY) gradient = cv2.convertScaleAbs(gradient) cv2.imshow("Gradient", gradient) #去噪&二值化 blurred = cv2.blur(gradient, (9, 9)) #平均模糊 (_, thresh) = cv2.threshold(blurred, 225, 255, cv2.THRESH_BINARY) cv2.imshow("Blurred", blurred) cv2.imshow("Thresh", thresh) #矩形内核 kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (21, 7)) closed = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel) cv2.imshow("Kernel", kernel) cv2.imshow("Closed", closed) #进行腐蚀和膨胀
def calculateLightPattern(image): # 光模式或背景近似结果 return cv2.blur(image, (image.cols / 3, image.cols / 3), 0)