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)
