def kernel_derivada(img, ordenX, ordenY, var, borde, sigma): img_mod = np.array(img, dtype=np.float32) if (var == 0): kernels = cv2.getDerivKernels(ordenX, 0, int(sigma * 6 + 1), normalize=True) else: kernels = cv2.getDerivKernels(0, ordenY, int(sigma * 6 + 1), normalize=True) img_mod = Gauss_kernel_deriv(np.array(img, dtype=np.float32), var, kernels[var], kernels[(var + 1) % 2]) if (sigma > 1): n_kernel = cv2.getGaussianKernel(int(sqrt(sigma - 1) * 6 + 1), int(sqrt(sigma - 1))) img_mod = Gauss_kernel_Grey(img_mod, int(sqrt(sigma - 1)), 1, n_kernel, 0) if (borde != 0): img_mod = cv2.copyMakeBorder(img_mod, 10, 10, 10, 10, borde) return img_mod
def piramide_derivada_gaussiana(imagen, k_size, tam_piramide, sigma): """ Pirámide con las derivadas de la gaussiana de la imagen. La usaremos para conocer los gradientes de una imagen a distintas escalas """ # alisamos la imagen kernel = kernel_gaussiano_1d(sigma) img_alisada = aplicar_convolucion(imagen, kernel, kernel) # obtenemos los kernels para cada eje mascara_x_kx, mascara_y_kx = cv.getDerivKernels(1, 0, k_size, normalize=True) mascara_x_ky, mascara_y_ky = cv.getDerivKernels(0, 1, k_size, normalize=True) # aplicamos las convoluciones img_dx = aplicar_convolucion(img_alisada, mascara_x_kx, mascara_y_kx) img_dy = aplicar_convolucion(img_alisada, mascara_x_ky, mascara_y_ky) # construimos la piramide con el primer nivel con las derivadas piramide_dx = [img_dx] piramide_dy = [img_dy] for i in range(1, tam_piramide): piramide_dx.append(cv.pyrDown(piramide_dx[i - 1])) piramide_dy.append(cv.pyrDown(piramide_dy[i - 1])) return piramide_dx, piramide_dy
def preprocess_filt_sob(self): ''' Do the pre processing using sobel filter (4.5/5.8 min). ''' import cv2 import numpy as np if self.zeroMask is not None: self.zeroMask = (self.I1 == 0) sobelx = cv2.getDerivKernels(1, 0, self.WallisFilterWidth) kernelx = np.outer(sobelx[0], sobelx[1]) sobely = cv2.getDerivKernels(0, 1, self.WallisFilterWidth) kernely = np.outer(sobely[0], sobely[1]) kernel = kernelx + kernely self.I1 = cv2.filter2D(self.I1, -1, kernel, borderType=cv2.BORDER_CONSTANT) self.I2 = cv2.filter2D(self.I2, -1, kernel, borderType=cv2.BORDER_CONSTANT)
def laplacian_gauss(img, sigma, abs_res=True, border=cv2.BORDER_CONSTANT, padding=True): tam = sigma2tam(sigma) # Kernels derivation and smoothing d2x = cv2.getDerivKernels(2, 0, tam) d2y = cv2.getDerivKernels(0, 2, tam) # d^2x and d^2y with the directional smoothing conv_x = conv_1D_1D(img, d2x, border, padding) conv_y = conv_1D_1D(img, d2y, border, padding) # d^2x + d^2y laplacian = conv_y + conv_x """ sigma^2(d^2x + d^2y) If we have very low values and not too high values, we can shift all the colors to the positive side, so we get that the zeros remain zeros and the negative values get closer to 1 (because they are higher than the positive). and the positive go to zero because by normalizing these are lower to the abs(negative) """ return (sigma * sigma) * (abs(laplacian) if abs_res else laplacian)
def get_derivatives(img): I = GaussianBlur(src=img, ksize=(11, 11), sigmaX=7) h_x1, h_x2 = cv2.getDerivKernels(1, 0, 3, normalize=True) h_y1, h_y2 = cv2.getDerivKernels(0, 1, 3, normalize=True) img_x = cv2.sepFilter2D(I, -1, h_x1, h_x2) img_y = cv2.sepFilter2D(I, -1, h_y1, h_y2) return img_x, img_y
def convol_1derivada(filename, sigma, border_type=cv2.BORDER_DEFAULT, visualize=True, read=True): # Tamaño de la máscara if sigma<=1: tamanio = int(6*sigma)+1 else: # sigma = 1 tamanio = 7 # Obtenemos los vectores de la máscara kernelDX = cv2.getDerivKernels(1,0, tamanio) kernelDY = cv2.getDerivKernels(0,1, tamanio) # Alisamiento gaussiano para intentar eliminar el ruido # y convolución con núcleo de 1ª derivada: # - Respecto de X blurX = convol_separable(filename, border_type, kernelDX[0], kernelDX[1], sigma, False, read=read) # - Respecto de Y blurY = convol_separable(filename, border_type, kernelDY[0], kernelDY[1], sigma, False, read=read) # Visualizamos if visualize: # visualization(images, titles, row, col, color = False) # visualization([cv2.imread(filename, 0), blurX, blurY], # ['Original', 'Derivada resp. X', 'Derivada resp. Y'], 1, 3, color=False) visualization([ blurX, blurY], ['', ''], 1, 2, color=False) return blurX, blurY
def laplaciana_de_gaussiana(imagen, border=cv2.BORDER_DEFAULT, ksize=3): # La función calcula y devuelve los coeficientes de filtro para derivadas (de orden 2 en el eje x) de imágenes espaciales. derivada2x0y = cv2.getDerivKernels(2, 0, ksize) # La función calcula y devuelve los coeficientes de filtro para derivadas (de orden 2 en el eje y) de imágenes espaciales. derivada0x2y = cv2.getDerivKernels(0, 2, ksize) return convolucion(imagen, derivada2x0y[0], derivada2x0y[1], border) + convolucion( imagen, derivada0x2y[0], derivada0x2y[1], border)
def derivadas(imagen, ksize=3, sigma=0, border=cv2.BORDER_DEFAULT): imagen = gaussian_blur(imagen, kx=ksize, ky=ksize, sigmax=sigma, sigmay=sigma) kx = cv2.getDerivKernels(1, 0, ksize) ky = cv2.getDerivKernels(0, 1, ksize) dx = convolucion(imagen, kx[0], kx[1], border=border) dy = convolucion(imagen, ky[0], ky[1], border=border) return dx, dy
def compute_gradient(img, use_scharr=True): if use_scharr: norm_factor = 32 gradx = cv2.Scharr(img, cv2.CV_32F, 1, 0, scale=1.0 / norm_factor) grady = cv2.Scharr(img, cv2.CV_32F, 0, 1, scale=1.0 / norm_factor) else: kx = cv2.getDerivKernels(1, 0, ksize=1, normalize=True) ky = cv2.getDerivKernels(0, 1, ksize=1, normalize=True) gradx = cv2.sepFilter2D(img, cv2.CV_32F, kx[0], kx[1]) grady = cv2.sepFilter2D(img, cv2.CV_32F, ky[0], ky[1]) gradient = np.dstack([gradx, grady]) return gradient
def EnergyRGB(src): # X derivative kx, ky = cv2.getDerivKernels(dx=1, dy=0, ksize=3) img_dx = cv2.sepFilter2D(src=src * 1.0, ddepth=-1, kernelX=kx, kernelY=ky) # Y derivative kx, ky = cv2.getDerivKernels(dx=0, dy=1, ksize=3) img_dy = cv2.sepFilter2D(src=src * 1.0, ddepth=-1, kernelX=kx, kernelY=ky) # Absolute sum for each channel img_e = abs(img_dx[:, :, 0]) + abs(img_dy[:, :, 0]) img_e = img_e + abs(img_dx[:, :, 1]) + abs(img_dy[:, :, 1]) img_e = img_e + abs(img_dx[:, :, 2]) + abs(img_dy[:, :, 2]) return img_e
def convMasks1D(im, dx, dy, ksize, border=cv2.BORDER_DEFAULT): # im: imagen a visualizar # title: título de la imagen # dx: orden derivada de x # dy: orden derivada de y # ksize: valor de ksize (aperture size) (1,3,5 o 7) # border: especifica el tipo de borde # pasamos a matriz de float im = im.astype(np.float32) # Calculamos los kernels de las derivadas # Normalizamos la máscara con normalize=True kerX, kerY = cv2.getDerivKernels(dx=dx, dy=dy, ksize=ksize, normalize=True) # trasponemos el kernel en el eje X kerX = np.transpose(kerX) # hacemos flip del kernel para aplicar convolución el lugar de # correlación kerX = np.flip(kerX) kerY = np.flip(kerY) # Aplicamos el filtro separable ker a la imagen # ddepth = -1 asigna la misma profundidad a la imagen nueva # aplicamos las máscaras 1D en ambas direcciones imconv = cv2.filter2D(im, ddepth=-1, kernel=kerX, borderType=border) imconv = cv2.filter2D(imconv, ddepth=-1, kernel=kerY, borderType=border) return imconv
def ConvolucionMascaraDerivadas(imagen,dx,dy,ksize,titulo): # Obtenemos los kernels de derivadas kernel = cv2.getDerivKernels(dx,dy, ksize=ksize) # si ddepth=-1, la imagen destino tendrá igual profundidad que la fuente # Pasamos el kernel por la imagen i2 = cv2.sepFilter2D(imagen, -1, kernel[0], kernel[1]) showImagenWait( i2, titulo )
def calculateConvSecondDerivative(im, x, y, size,border=cv.BORDER_DEFAULT): """ Calculates 2D convolution with a mask of second derivatives Parameters ---------- im : matrix_like An image in OpenCV format size : int Size of the mask that will be applied to the image Returns ------- type Opencv matrix comes from numpy """ dx = None dy = None if x and y: dx = 2 dy = 2 elif x: dx = 2 dy = 0 else: dx = 0 dy = 2 kerX, kerY = cv.getDerivKernels(dx, dy, size) matrix = kerY*np.transpose(kerX) return cv.filter2D(im,-1,matrix, borderType=border)
def computer_exercise6(): I = sio.loadmat('HW4\\hw4_data\\imgs_for_optical_flow.mat')['img1'] h_row, h_col = cv2.getDerivKernels(1, 0, 3) hx = h_col.dot(h_row.T) hy = hx.T fig, axs = plt.subplots(1, 5) cols = ['I', 'dI/dx', 'dI/dy', 'dI/dxx', 'dI/dyy'] # original image axs[0].imshow(I, cmap='gray') # dI/dx Ix = cv2.filter2D(I, -1, hx, borderType=cv2.BORDER_CONSTANT) axs[1].imshow(Ix, cmap='gray') # dI/dy Iy = cv2.filter2D(I, -1, hy, borderType=cv2.BORDER_CONSTANT) axs[2].imshow(Iy, cmap='gray') # dI/dxx Ixx = cv2.filter2D(Ix, -1, hx, borderType=cv2.BORDER_CONSTANT) axs[3].imshow(Ixx, cmap='gray') # dI/dy Iyy = cv2.filter2D(Iy, -1, hy, borderType=cv2.BORDER_CONSTANT) axs[4].imshow(Iyy, cmap='gray') for i in range(0, len(cols)): axs[i].set(xlabel=cols[i]) for ax in axs.flat: ax.set_xticks([]) ax.set_yticks([]) plt.show()
def get_derivatives2D(dx, dy, size): """Calcula máscaras de derivadas normalizadas. - dx: orden de la derivada en X. - dy: orden de la derivada en Y. - size: tamaño de las máscaras. Debe ser impar.""" return map(lambda x: x.astype(np.double).flatten(), cv2.getDerivKernels(dx, dy, size, normalize = True))
def calculateImageGradient(self, inputImage): # input image is logical kernelGaussian = cv2.getGaussianKernel(5,1.5) kernelg = np.outer(kernelGaussian, kernelGaussian.transpose()) #kernelg = np.outer(kernelGaussian[0], kernelGaussian[1]) inputImage = cv2.filter2D(inputImage,-1,kernelg,borderType = cv2.BORDER_REPLICATE) sobely = cv2.getDerivKernels(1,0,3) kernely = np.outer(sobely[0], sobely[1]) gyImage = cv2.filter2D(inputImage,-1, cv2.flip(kernely,-1),borderType = cv2.BORDER_REPLICATE) gyImage = gyImage.astype(np.float32) sobelx = cv2.getDerivKernels(0,1,3) kernelx = np.outer(sobelx[0], sobelx[1]) gxImage = cv2.filter2D(inputImage,-1, cv2.flip(kernelx,-1),borderType = cv2.BORDER_REPLICATE) gxImage = gxImage.astype(np.float32) gImage = np.sqrt(gxImage*gxImage+gyImage*gyImage) return gxImage, gyImage, gImage
def maskDerivKernels(img, dx=1, dy=1, ksize=3, border=cv2.BORDER_REPLICATE): """ getDerivKernels returns coefficients to get images partial derivatives. dx and dy are respectively the partial orders for x and y. """ dxdy = cv2.getDerivKernels(dx, dy, ksize, normalize=0) return convolution2D(img, dxdy[0], dxdy[1], border)
def ConvolucionPrimeraDerivada(nombre_imagen, tam, indice): i2b = leeimagen(nombre_imagen, 0) i2b = addBorders(i2b, cv2.BORDER_CONSTANT, 10, 0) kernel = cv2.getDerivKernels(1,1,tam) i2b = cv2.sepFilter2D(i2b, -1, kernel[0], kernel[1]) showImagenWait( i2b, 'Convolucion 2B'+indice )
def get_cv2_kernel(win_size, smoothing): d, s = cv2.getDerivKernels(2, 0, win_size) if not smoothing: s = np.zeros(win_size) s[win_size // 2] = 1. windows = [[d if i == j else s for j in range(num_dims)] for i in range(num_dims)] return sum(outer(*ws) for ws in windows)
def derive_convolution(derivX = 0, derivY = 0, size = 7, normal = True): #Ksize = 1, 3, 5, 7 if ((size == 1) or (size == 3) or (size == 5) or (size == 7)): return cv2.getDerivKernels(dx = derivX, dy = derivY, ksize = size, normalize = normal, ktype = cv2.CV_64F) #Si el Ksize no es valido se obtiene error else: print('El tamaño debe ser 1, 3, 5 o 7') sys.exit()
def convolucion1D(imagen, dX=0, dY=0, ksize=7, border=cv2.BORDER_REPLICATE): if ((ksize == 1) or (ksize == 3) or (ksize == 5) or (ksize == 7)): # La función calcula y devuelve los coeficientes de filtro para derivadas de imágenes espaciales. derivada = cv2.getDerivKernels(dx=dX, dy=dY, ksize=ksize, ktype=cv2.CV_64F) imagen = convolucion(imagen, derivada[0], derivada[1], border) return imagen else: sys.exit('El ksize debe ser 1, 3, 5 o 7')
def ap1B(dx, dy, tam): """Obtiene máscaras 1D de máscaras derivadas. Argumentos posicionales: - dx: orden de derivación respecto de x - dy: orden de derivación respecto de y - tam: tamaño del kernel Devuelve: Vectores de derivada """ return cv.getDerivKernels(dx, dy, tam)
def cv_GetDerivKernels(dx=('IntPin', 2), dy=('IntPin', 2), ksize=('IntPin', 0), normalize=('BoolPin', False), kx=(REF, ('ImagePin', 0)), ky=(REF, ('ImagePin', 0))): """ Blurs An image.""" if ksize == 0: ksize = cv2.FILTER_SCHARR x, y = cv2.getDerivKernels(dx, dy, ksize, normalize) kx(x) ky(y)
def separable_second_derivate(img, dx, dy, size, border): ''' Cálculo de la convolución separable con máscaras de segunda derivada. Los argumentos dx y dy son booleanos true indica que se realiza la segunda derivada correspondiente. Nota: dx y dy no pueden ser falsos a la vez. ''' if dx or dy: kernel = cv2.getDerivKernels(dx * 2, dy * 2, size) return separable_convolution(img, kernel[0], kernel[1], border)
def get_windows(window_sizes): axes = len(window_sizes) d_windows = {window_sizes[i][i]: None for i in range(axes)} s_windows = { window_sizes[i][j]: None for i in range(axes) for j in range(axes) if i != j } for window_size in d_windows: d, s = cv2.getDerivKernels(2, 0, ksize=window_size) d_windows[window_size] = d.reshape(-1) if window_size > 1 and window_size in s_windows and s_windows[ window_size] is None: s_windows[window_size] = s.reshape(-1) for window_size in s_windows: if s_windows[window_size] is None: if window_size == 1: s_windows[window_size] = np.array([1.], dtype=np.float32) else: _, s = cv2.getDerivKernels(2, 0, ksize=window_size) s_windows[window_size] = s.reshape(-1) return [[(d_windows if i == j else s_windows)[window_sizes[i][j]] for j in range(axes)] for i in range(axes)]
def Q6(): mdict_of = sio.loadmat('hw4_data/hw4_data/imgs_for_optical_flow.mat') img_of = mdict_of['img1'] I_blur = cv2.GaussianBlur(img_of, (7, 7), 0.2) fig = plt.figure(7, figsize=(15, 10)) ax = fig.add_subplot(1, 6, 1) ax.title.set_text('Original') ax.imshow(img_of, cmap='gray') ax = fig.add_subplot(162) ax.set_title('Blurred') ax.imshow(I_blur, cmap='gray') h_x1, h_x2 = cv2.getDerivKernels(1, 0, 3) I_x = cv2.sepFilter2D(I_blur, -1, h_x1, h_x2) ax = fig.add_subplot(163) ax.set_title('dx') ax.imshow(I_x, cmap='gray') h_y1, h_y2 = cv2.getDerivKernels(0, 1, 3) I_y = cv2.sepFilter2D(I_blur, -1, h_y1, h_y2) ax = fig.add_subplot(164) ax.set_title('dy') ax.imshow(I_y, cmap='gray') h_x1_2, h_x2_2 = cv2.getDerivKernels(2, 0, 3) I_x2 = cv2.sepFilter2D(I_blur, -1, h_x1_2, h_x2_2) ax = fig.add_subplot(165) ax.set_title('dxx') ax.imshow(I_x2, cmap='gray') h_y1_2, h_y2_2 = cv2.getDerivKernels(0, 2, 3) I_y2 = cv2.sepFilter2D(I_blur, -1, h_y1_2, h_y2_2) ax = fig.add_subplot(166) ax.set_title('dyy') ax.imshow(I_y2, cmap='gray')
def getDerivs(image, sigma): """ Helper function for harris function Take in image and sigma Get gradient derivatives in x and y directions Return derivatives """ ksize = (int(4 * sigma + 1), int(4 * sigma + 1)) imgGauss = cv.GaussianBlur(image.astype(np.float64), ksize, sigma) kx, ky = cv.getDerivKernels(1, 1, 3) kx = np.transpose(kx / 2) ky = ky / 2 imgDx = cv.filter2D(imgGauss, -1, kx) imgDy = cv.filter2D(imgGauss, -1, ky) return imgDx, imgDy
def obtainMasks(dx,dy,size): """ A function that returns 1D masks to calculate derivative masks 2D convolution Parameters ---------- size : int An int representing the size of the mask Returns ------- type Numpy array """ return cv.getDerivKernels(dx,dy,size)
def applyDeriv(img, ksize, der=1): # Obtenemos las dos componentes separadas (horizontal, # y vertical) y las aplicamos # Definimos normalize=True porque aplicamos la # derivada a imágenes en coma flotante. Referencia: # https://docs.opencv.org/3.4.3/d4/d86/group__imgproc__filter.html#ga6d6c23f7bd3f5836c31cfae994fc4aea kx, ky = cv2.getDerivKernels(der, der, ksize, normalize=True) # el segundo valor (ddepth) lo definimos como -1 # para que OpenCV devuelve la imagen en el mismo # tipo de dato que la mandamos. Referencia: # https://docs.opencv.org/3.4.3/d4/d86/group__imgproc__filter.html#ga910e29ff7d7b105057d1625a4bf6318d out = cv2.sepFilter2D(img, -1, kx, ky) return out
def ConvolucionDeriv(img, size, ordenX, ordenY): borderImage = cv.copyMakeBorder(img, 5, 5, 5, 5, cv.BORDER_CONSTANT) blurredImg = cv.GaussianBlur(src=borderImage, ksize=(0, 0), sigmaX=1, sigmaY=1) kernels = cv.getDerivKernels(dx=ordenX, dy=ordenY, ksize=size, normalize=False) print('Kernel en X\n', kernels[0], '\nKernel en Y\n', kernels[1]) print('Matriz', kernels[1].dot(kernels[0].transpose())) return Convolucion2D(img=blurredImg, kernels=kernels, txt=0)
# Parameters for lucas kanade optical flow lk_params = dict( winSize = (15,15), maxLevel = 2, criteria = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 0.03)) # Create some random colors color = np.random.randint(0,255,(100,3)) # Take first frame and find corners in it ret, old_frame = cap.read() frame_gray = cv2.cvtColor(old_frame, cv2.COLOR_BGR2GRAY) sigma = 1.5 ksize = (int(4*sigma+1),int(4*sigma+1)) im_s = cv2.GaussianBlur(frame_gray, ksize, sigma) kx,ky = cv2.getDerivKernels(1,1,3) kx = np.transpose(kx/2) ky = ky/2 im_dx = cv2.filter2D(im_s,-1,kx) im_dy = cv2.filter2D(im_s,-1,ky) im_gm = np.sqrt( im_dx**2 + im_dy**2) # gradient magnitude im_gm_int = im_gm.astype(np.uint8) gradients = np.sort(im_gm_int, axis=None)[::-1] # This flattens before sorting and then reverses the order index1 = int(0.2 * len(gradients)) # print index1, gradients[index1] rv,im_thresh1 = cv2.threshold(im_gm_int, 120, 255., cv2.THRESH_TRUNC) # plt.imshow(im_thresh1, cmap = cm.Greys_r) # plt.show() kernel = np.ones((5,5),np.uint8)