def line_detection(image, verbose=False): # Líneas Horizontales print('\n') print("LÍNEAS HORIZONTALES") # Definimos el filtro para la detección de líneas horizontal kernel = np.array([[-1, -1, -1], [2, 2, 2], [-1, -1, -1]]) # Realizamos la convolución con la imagen y el kernel anterior image_lines_x = convolution(image, kernel, False) # Se muestra la imagen con la detección de líneas horizontales. if verbose: plt.imshow(image_lines_x, cmap='gray') plt.title("Horizontal Lines") plt.show() # Líneas verticales print('\n') print("LÍNEAS VERTICALES") kernel = (kernel.T) image_lines_y = convolution(image, kernel, False) if verbose: plt.imshow(image_lines_y, cmap='gray') plt.title("Vertical Lines") plt.show() # Líneas a 45° print('\n') print("LÍNEAS 45°") kernel = np.array([[-1, -1, 2], [-1, 2, -1], [2, -1, -1]]) image_lines_45_dgrs = convolution(image, kernel, False) if verbose: plt.imshow(image_lines_45_dgrs, cmap='gray') plt.title("45 Degree Lines") plt.show() # Líneas 135° print('\n') print("LÍNEAS 135°") kernel = np.fliplr(kernel) image_lines_135_dgrs = convolution(image, kernel, False) if verbose: plt.imshow(image_lines_135_dgrs, cmap='gray') plt.title("135 Degree Lines") plt.show() # Obtenemos las líneas juntando las imágenes anteriores. print('\n') print("LINE DETECTION") image = image_lines_x + image_lines_y + image_lines_45_dgrs + image_lines_135_dgrs if verbose: plt.imshow(image, cmap='gray') plt.title("Line Detection") plt.show() return image
def sobel_edge_detection(image, filter, convert_to_degree=False, verbose=False): new_image_x = convolution(image, filter, verbose) if verbose: plt.imshow(new_image_x, cmap='gray') plt.title("Horizontal Edge") plt.show() new_image_y = convolution(image, np.flip(filter.T, axis=0), verbose) if verbose: plt.imshow(new_image_y, cmap='gray') plt.title("Vertical Edge") plt.show() gradient_magnitude = np.sqrt( np.square(new_image_x) + np.square(new_image_y)) gradient_magnitude *= 255.0 / gradient_magnitude.max() if verbose: plt.imshow(gradient_magnitude, cmap='gray') plt.title("Gradient Magnitude") plt.show() gradient_direction = np.arctan2(new_image_y, new_image_x) if convert_to_degree: gradient_direction = np.rad2deg(gradient_direction) gradient_direction += 180 return new_image_x, new_image_y, gradient_magnitude, gradient_direction
def border_detection(img, kernelx, kernely): imx = convolution.convolution(img, kernelx) imx = imx.astype(np.float) imy = convolution.convolution(img, kernely) imy = imy.astype(np.float) r = np.power(np.power(imx, 2)+np.power(imy, 2), 0.5) / np.sqrt(2.0) t = np.arctan(imy / (imx + 0.00001)) return r, t
def border_detection(img, kernelx, kernely): imx = convolution.convolution(img, kernelx) imx = imx.astype(np.float) imy = convolution.convolution(img, kernely) imy = imy.astype(np.float) imx = np.power(imx, 2) imy = np.power(imy, 2) r = convolution.scale(np.power(imx + imy, 0.5)) / np.sqrt(2) convolution.apply_threshold(r, 150) return r
def mean_filter(image, kernel_size, iterations, verbose=False): kernel = mean_kernel(kernel_size) output = np.zeros(image.shape) for k in range(0, iterations): if k == 0: output = convolution(image, kernel, verbose=verbose) else: image = output output = convolution(image, kernel, verbose=verbose) return output
def prewitt_edge_detection(image): vertical_filter = np.array([[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]]) horizontal_filter = np.flip( vertical_filter.T, axis=0) # array([[1, 1, 1], [0, 0, 0], [-1, -1, -1]]) prewitt_x = convolution(image, vertical_filter, verbose=False) prewitt_y = convolution(image, horizontal_filter, verbose=False) # calculate gradient magnitude prewitt = np.hypot(prewitt_x, prewitt_y) prewitt *= 255.0 / prewitt.max() return prewitt_x, prewitt_y, prewitt
def sobel_edge_detection(image, filter): new_image_x = convolution(image, filter) new_image_y = convolution(image, np.flip(filter.T, axis=0)) gradient_magnitude = np.sqrt( np.square(new_image_x) + np.square(new_image_y)) gradient_magnitude *= 255.0 / gradient_magnitude.max() gradient_direction = np.arctan2(new_image_y, new_image_x) gradient_direction = np.rad2deg(gradient_direction) gradient_direction += 180 return gradient_magnitude, gradient_direction
def down(image, expected_shape=None): # Desce um nivel na piramide # Duplica linhas e colunas image_down = np.repeat(image, 2, axis=0) image_down = np.repeat(image_down, 2, axis=1) #Interpolation with a 3x3 box blur kernel. msk = np.full((3, 3), 1 / (3 * 3)) image_down = conv.convolution(image_down, msk) # Fix the shape in case the lower image was odd if expected_shape is not None: if image_down.shape[0] > expected_shape[0]: image_down = np.delete(image_down, image_down.shape[0] - 1, axis=0) if image_down.shape[0] != expected_shape[0]: print("Wrong shape in the axis=0.") return None if image_down.shape[1] > expected_shape[1]: image_down = np.delete(image_down, image_down.shape[1] - 1, axis=1) if image_down.shape[1] != expected_shape[1]: print("Wrong shape in the axis=1.") return None return image_down
def ej_c(im1): gaussian = np.ones((5, 5), dtype=np.float) gaussian[:, :] = [[1, 4, 7, 4, 1], [4, 16, 26, 16, 4], [7, 26, 41, 26, 7], [4, 16, 26, 16, 4], [1, 4, 7, 4, 1]] gaussian[:, :] *= 1. / 273 im2 = convolution.convolution(im1, gaussian) return ej_a(im2)
def gaussiano(im): gaussian = np.ones((5, 5), dtype=np.float) gaussian[:, :] = [[1, 4, 7, 4, 1], [4, 16, 26, 16, 4], [7, 26, 41, 26, 7], [4, 16, 26, 16, 4], [1, 4, 7, 4, 1]] gaussian[:, :] *= 1. / 273 return convolution.convolution(im, gaussian)
def gaussian_blur(image, kernel_size, iterations, verbose=False): kernel = gaussian_kernel(kernel_size, sigma=math.sqrt(kernel_size)) output = np.zeros(image.shape) for k in range(0, iterations): if k == 0: output, plt = convolution(image, kernel, average=True, verbose=verbose) else: image = output output, plt = convolution(image, kernel, average=True, verbose=verbose) return output, plt
def up(image): msk = np.array([[1, 4, 6, 4, 1], [4, 16, 24, 16, 4], [6, 24, 36, 24, 6], [4, 16, 24, 16, 4], [1, 4, 6, 4, 1]]) msk = msk / np.sum(msk) # Blur image_up = conv.convolution(image, msk) # Remove linhas e colunas pares image_up = image_up[::2, ::2] return image_up
def sobel_edge_detection(image, convert_to_degree=False): vertical_filter = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]) horizontal_filter = vertical_filter.T # array([[-1, -2, -1],[ 0, 0, 0],[ 1, 2, 1]]) sobel_x = convolution(image, vertical_filter, verbose=False) sobel_y = convolution(image, horizontal_filter, verbose=False) # calculate gradient magnitude G = np.hypot( sobel_x, sobel_y) # np.hypot() = sqrt(img_x**2 + img_2**2) -> hypotenuse G *= 255.0 / G.max() # calculate gradient direction G_theta = np.arctan2(sobel_x, sobel_y) if convert_to_degree: G_theta = np.rad2deg(G_theta) G_theta += 180 return sobel_x, sobel_y, G, G_theta
def myEdgeFilter(img0, sigma): # smooth out the image hsize = 2 * math.ceil(3 * sigma) + 1 kernal = cv2.getGaussianKernel(hsize, sigma) smoothImg = convolution(img0, kernal) # calculate x direction sobel kernal = numpy.array(([-1, 0, 1], [-2, 0, 2], [-1, 0, 1])) xSobel = convolution(smoothImg, kernal) cv2.imwrite("xSobel.png", xSobel) # calculate y direction sobel kernal = numpy.array(([-1, -2, -1], [0, 0, 0], [1, 2, 1])) ySobel = convolution(smoothImg, kernal) cv2.imwrite("ySobel.png", ySobel) # add x and y sobel # G(i,j) = sqrt(I^2(i,j) + I^2(i,j)) sobel = numpy.sqrt(numpy.square(xSobel) + numpy.square(ySobel)) cv2.imwrite("gradient magnitude.png", sobel) suppression = compare(xSobel, ySobel, sobel) cv2.imwrite("Non-Maximum Suppression.png", suppression)
def laplacian(image, verbose=False): #se define el kernel usado para este filtro kernel = np.array([[0, 0, -1, 0, 0], [0, -1, -2, -1, 0], [-1, -2, -16, -2, -1], [0, -1, -2, -1, 0], [0, 0, -1, 0, 0]]) #se hace la convolucion usando el kernel declarado image_lap = convolution(image, kernel, False) #se muestra la imagen if verbose: plt.imshow(image_lap, cmap='gray') plt.title('laplacian') plt.show() return image
def fft_mul(self, other): dnew = self.ldegree + other.ldegree sizenew = len(self) + len(other) c = LPoly(convolution(self, other)) #print c[0][0] #print "c=",c c.setbot(dnew) m = self.modulus if m: c.setmodulus(m) for i in xrange(len(c)): #print sum(c[i]) c[i] = sum(c[i]) % m else: for i in xrange(len(c)): c[i] = sum(c[i]) return c
def fft_mul_slice(self, other): SLICES = 222 vsize = len(self[0]) for i in xrange(1 + (vsize - 1) / SLICES): if SLICES == 1: if (i % 50) == 0: print i, " of ", 1 + (vsize - 1) / SLICES otherslice = [si[i] for si in other] selfslice = [si[i] for si in self] else: if (i % 10) == 0: print i, " of ", 1 + (vsize - 1) / SLICES otherslice = [ Ve(si[i * SLICES:(i + 1) * SLICES]) for si in other ] selfslice = [ Ve(si[i * SLICES:(i + 1) * SLICES]) for si in self ] #selfslice.ldegree=self.ldegree #if self.modulus: selfslice.modulus=self.modulus #otherslice.ldegree=self.ldegree #if other.modulus: otherslice.modulus=self.modulus if SLICES == 1: ct = LPoly(convolution_scalar(selfslice, otherslice)) ct.setmodulus(self.modulus) else: ct = LPoly(convolution(selfslice, otherslice)) if i == 0: c = ct #c.setmodulus(self.modulus) else: c = c + ct % self.modulus dnew = self.ldegree + other.ldegree c.setbot(dnew) m = self.modulus if SLICES != 1: c.setmodulus(m) for i in xrange(len(c)): #if SLICES==1: # c[i]=c[i]%m #else: c[i] = sum(c[i]) % self.modulus return c
def ej_a(im1): K1, K2 = im1.shape im2 = convolution.convolution(im1, laplaciano) r = np.zeros(im1.shape, dtype=np.float) maximum = 0.0 minimum = 0.0 median = mediana_difs(im2) * 2.0 for k1 in range(1, K1 - 1): for k2 in range(1, K2 - 1): indices = [((k1 - 1, k2 - 1), (k1 + 1, k2 + 1)), ((k1, k2 - 1), (k1, k2 + 1)), ((k1 - 1, k2), (k1 + 1, k2)), ((k1 + 1, k2 - 1), (k1 - 1, k2 + 1))] found = False for i1, i2 in indices: p1 = im2[i1[0], i1[1]] p2 = im2[i2[0], i2[1]] if p1 * p2 < 0 and abs(p1 - p2) > median: found = True break r[k1, k2] = 255 if found else 0 return r
def ej_b(im1): K1, K2 = im1.shape im2 = convolution.convolution(im1, laplaciano) r = np.zeros(im1.shape, dtype=np.float) maximum = 0.0 minimum = 0.0 mediana = mediana_difs(im2) * 2.0 for k1 in range(1, K1 - 1): for k2 in range(1, K2 - 1): indices = [((k1 - 1, k2 - 1), (k1 + 1, k2 + 1)), ((k1, k2 - 1), (k1, k2 + 1)), ((k1 - 1, k2), (k1 + 1, k2)), ((k1 + 1, k2 - 1), (k1 - 1, k2 + 1))] found = False varianza = varianza_local(im2, 2, k1, k2) if varianza < VARIANZA_THRESHOLD: continue for i1, i2 in indices: p1 = im2[i1[0], i1[1]] p2 = im2[i2[0], i2[1]] if p1 * p2 < 0 and abs(p1 - p2) >= mediana: found = True break r[k1, k2] = 255 if found else 0 return r
# Call Option Pricing with Circular Convolution (General) import numpy as np from convolution import revnp, convolution from parameters import * # Parameter Adjustments M = 3 #numberoftimesteps dt, df, u, d, q = get_binomial_parameters(M) # Array Generation for Stock Prices mu = np.arange(M + 1) mu = np.resize(mu, (M + 1, M + 1)) md = np.transpose(mu) mu = u**(mu - md) md = d**md S = S0 * mu * md # Valuation V = np.maximum(S - K, 0) qv = np.zeros((M + 1), dtype=np.float) qv[0] = q qv[1] = 1 - q for t in range(M - 1, -1, -1): V[:, t] = convolution(V[:, t + 1], revnp(qv)) * df print("Value of the Call Option %8.3f" % V[0, 0])
def conv(image, label, params, conv_s, pool_f, pool_s): ''' Combine the forward and backward propogation to build a method that takes the input parameters and hyperparamets as inputs and outputs gradient and loss ''' [f1, f2, w3, w4, b1, b2, b3, b4] = params #filters, weights and biases ############################################# ###########Forward operation################# ############################################# conv1 = convolution(image, f1, b1, conv_s) conv1[conv1 <= 0] = 0 #apply ReLU non-linearity cov2 = convolution(conv1, f2, b2, conv_s) conv2[conv2 <= 0] = 0 pooled = maxpool(conv2, pool_f, pool_s) #maxpooling (nf2, dim2, _) = pooled.shape fc = pooled.reshape((nf2 * dim2 * dim2, 1)) #flatten pooled layer z = w3.dot( fc) + b3 #pass flattened pool through first fully connected layer z[z <= 0] = 0 #pass through ReLU function out = w4.dot(z) + b4 #pass through second layer probs = softmax( out ) #apply softmax activation function to find prodicted probabilities ############################################# ############# Loss ########################## ############################################# loss = categoricalCrossEntropy(probs, label) ############################################## ############ Backward operation ############## ############################################## d_out = probs - label #derivate of loss w.r.t final dense layer dw4 = d_out.dot(z.T) #loss gradient weights db4 = np.sum(d_out, axis=1).reshape(b4.shape) #loss gradient of biases dz = w4.T.dot(d_out) #loss gradient of first dense layer outputs dz[z <= 0] = 0 #ReLU dw3 = dz.dot(fc.T) #loss function os weights db3 = np.sum(dz, axis=1).reshape(b3.shape) dfc = w3.T.dot(dz) #loss gradient of fully connested pooling layer dpool = dfc.reshape( pooled.shape) #reshape into into dimension of pooling layer dconv2 = maxoolBackward(dpool, conv2, pool_f, pool_s) dconv2[conv2 <= 0] = 0 dconv1, df2, db2 = convolutionBackward(dconv2, conv1, f2, conv_s) dconv1[conv1 <= 0] = 0 dimage, df1, db1 = convolutionBackward(dconv1, image, f1, convs) grads = [df1, df2, dw3, dw4, db1, db2, db3, db4] return grads, loss
low_pass_5 = np.ones((5, 5), dtype=np.float) low_pass_5[:, :] = 1. / 25 high_pass_3 = np.ones((3, 3), dtype=np.float) high_pass_3[:, :] /= -9.0 high_pass_3[1, 1] = 8. / 9 high_pass_5 = np.ones((5, 5), dtype=np.float) high_pass_5[:, :] /= -25.0 high_pass_5[2, 2] = 24. / 25 kernels = { "low": { "3": low_pass_3, "5": low_pass_5 }, "high": { "3": high_pass_3, "5": high_pass_5 } } im1 = np.asarray(Image.open(argv[1]).convert('L')) im2 = convolution.convolution(im1, kernels[argv[2]][argv[3]]) print(im1) print(im2) side_by_side.sbys( [im1, im2], ["Original", argv[2] + "-pass filter de " + argv[3] + "x" + argv[3]], argv=None if len(argv) <= 4 else argv[4])
from ast import literal_eval from PIL import Image import csv import sys import convolution image = Image.open("mandrill.png") pixels = image.load() size = image.size reader = csv.reader(sys.stdin, delimiter=';') gaussian_blur = convolution.generate_centered_gaussian_convolution_matrix(5, 16, 16) for line in reader: index = literal_eval(line[0]) x = index[0] y = index[1] new_pixel = convolution.convolution(convolution.unsharp_kernel, pixels, x, y, size[0], size[1]) print("{0}\t{1}\t{2}\t{3}\t{4}".format(x, y, int(new_pixel[0]), int(new_pixel[1]), int(new_pixel[2])))
def gaussian_blur(image, kernel_size, sigma, verbose=False): kernel = gaussian_kernel(kernel_size, sigma, verbose=verbose) return convolution(image, kernel, average=True, verbose=verbose)
def dft(sequence, reference=None): if None == reference: N = len(sequence) seq_a = list(sequence) else: N = len(reference) seq_a = list(reference) seq_a_target = list(sequence) fun_p = bma(seq_a * 2) # turn sequence as periodic L = fun_p.degree() # assert 2 * L <= len(seq_a) # selection of parameters # fine smallest n, s.t. N | (2^n - 1) n = 1 while 0 != (2 ** n - 1) % N: # this means N cannot be even number n += 1 # print n # define the extension field TheExtensionField = GF(2 ** n, "beta") beta = TheExtensionField.gen() fun_f = TheExtensionField.polynomial() TheExtensionPolynomialRing = TheExtensionField["Y"] # print fun_f # construct a new m-seq {b_t} seq_b_iv = [] for i in range(n): seq_b_iv.append((beta ** i).trace()) seq_b_generator = lfsr(seq_b_iv, fun_f) seq_b = [] for i in range(2 ** len(seq_b_iv) - 1): seq_b.append(seq_b_generator.next()) # print seq_b_iv # print seq_b # let alpha be an element in GF(2^n) with order N alpha = beta ** ((2 ** n - 1) / N) # print alpha, alpha ** N # procedure # step 1. compute coset I = coset(N) # print I # step 2. fun_p_extended = TheExtensionPolynomialRing(fun_p) # print fun_p_extended spectra_A = [None] * N spectra_A_target = [None] * N for k in I: if fun_p_extended(alpha ** k) != 0: spectra_A[k] = 0 if reference: spectra_A_target[k] = 0 continue # print 'k', k, fun_p_extended(alpha ** k) # sub-routine for computing A_k # 1. get coset size m = I[k] # print k, m, n # 2. k-decimation sequence seq_c = [] if m == n: for t in range(2 * m): seq_c.append(seq_b[(t * k) % (2 ** n - 1)]) elif m < n: for t in range(2 * m): seq_c.append(trace(alpha ** (k * t), m)) else: import sys sys.stderr.write("should never happen?\n") sys.exit(-1) # print seq_b # print seq_c fun_p_k = bma(seq_c) # print fun_p # print fun_p_k # print fun_p / fun_p_k matrix_M_ele = [] for i in range(m): for ele in range(i, m + i): matrix_M_ele.append(seq_c[ele]) matrix_M = matrix(GF(2), m, m, matrix_M_ele) # print 'matrix_M' # print matrix_M # 3. contruct a filter fun_q = fun_p.parent()(fun_p / fun_p_k) # print fun_q # print type(fun_q) # 4. compute the time convolution seq_v_generator = convolution(seq_a, fun_q) seq_v = [] for i in range(m): seq_v.append(seq_v_generator.next()) if reference: seq_v_target_generator = convolution(seq_a_target, fun_q) seq_v_target = [] for i in range(m): seq_v_target.append(seq_v_target_generator.next()) # 4.5 solve linear equations to get x_i matrix_x = matrix_M.inverse() * matrix(GF(2), m, 1, seq_v) # print 'matrix_x' # print matrix_x if reference: matrix_x_target = matrix_M.inverse() * matrix(GF(2), m, 1, seq_v_target) # print 'matrix_x_target' # print matrix_x_target # 5. compute A_k = V * T V = 0 for i in range(m): if 1 == matrix_x[i][0]: V += alpha ** (i * k) if reference: V_target = 0 for i in range(m): if 1 == matrix_x_target[i][0]: V_target += alpha ** (i * k) fun_q_extended = TheExtensionPolynomialRing(fun_q) # print fun_q_extended T = fun_q_extended(alpha ** k) ** (-1) # print T # print type(T) A_k = V * T # print A_k spectra_A[k] = A_k if reference: A_k_target = V_target * T spectra_A_target[k] = A_k_target # print spectra_A # print spectra_A_target # to compute the A_k where k is not coset leader for i in I: for j in range(1, I[i]): spectra_A[(i * (2 ** j)) % N] = spectra_A[i] ** (2 ** j) if reference: spectra_A_target[(i * (2 ** j)) % N] = spectra_A_target[i] ** (2 ** j) # print alpha ** 6 if None == reference: return spectra_A else: return spectra_A, spectra_A_target
# 06_fou/call_convolution_general.py # # (c) Dr. Yves J. Hilpisch # Derivatives Analytics with Python # import numpy as np from convolution import revnp, convolution from parameters import * # Parmeter Adjustments M = 3 # number of time steps dt, df, u, d, q = get_binomial_parameters(M) # Array Generation for Stock Prices mu = np.arange(M + 1) mu = np.resize(mu, (M + 1, M + 1)) md = np.transpose(mu) mu = u ** (mu - md) md = d ** md S = S0 * mu * md # Valuation V = np.maximum(S - K, 0) qv = np.zeros((M + 1), dtype=np.float) qv[0] = q qv[1] = 1 - q for t in range(M - 1, -1, -1): V[:, t] = convolution(V[:, t + 1], revnp(qv)) * df print("Value of the Call Option %8.3f" % V[0, 0])
1.- Edge detection 2.- Sobel 3.- Line detection horizontal 4.- Cambiar de imagen 5.- Salir """ pop = True #Breack del ciclo while. while pop == True: #Ciclo while para imprimir filtros, cambiar imagen o salir. print(filtros) print("Elige una opcion:") op = input() if op == "1": edgeDetection = np.array([[-1, -1, -1], [-1, 8, -1], [-1, -1, -1]]) imageEdge = convolution( image, edgeDetection) # Función de convolución con padding # Mostrar el plot del resultado con filtro. plt.imshow(imageEdge, cmap='twilight_shifted') edge_row, edge_col = imageEdge.shape plt.title("Output Edge detection of {}X{}".format( edge_row, edge_col)) plt.show() elif op == "2": sobel = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]) imageSobel = convolution( image, sobel) # Función de convolución con padding # Mostrar el plot del resultado con filtro. plt.imshow(imageSobel, cmap='twilight_shifted') sobel_row, sobel_col = imageSobel.shape plt.title("Output Sobel of {}X{}".format(sobel_row, sobel_col)) plt.show()
def gaussian_blur(image, kernel_size, steps=False): kernel = gaussian_kernel(kernel_size, sigma=math.sqrt(kernel_size), steps=steps) return convolution(image, kernel, average=True, steps=steps)
# # Call Option Pricing with Circular Convolution (Simple) # 06_fou/call_convolution.py # # (c) Dr. Yves J. Hilpisch # Derivatives Analytics with Python # import math import numpy as np from convolution import revnp, convolution # Parameter Definitions M = 4 # number of time steps dt = 1.0 / M # length of time interval r = 0.05 # constant short rate C = [49.18246976, 22.14027582, 0, 0, 0] # call payoff at maturity q = 0.537808372 # martingale probability qv = np.array([q, 1 - q, 0, 0, 0]) # probabilitiy vector filled with zeros # Calculation V = np.zeros((M + 1, M + 1), dtype=np.float) V[M] = C for t in range(M - 1, -1, -1): V[t] = convolution(V[t + 1], revnp(qv)) * math.exp(-r * dt) print "Value of the Call Option %8.3f" % V[0, 0]
def update_parameters(filt, gradient_val, bias, biasgradient_value): alpha=0.001 filt= filt - (alpha * gradient_val) bias=bias-(alpha * biasgradient_value) return filt, bias def l2loss(param1, param2): loss=((param1 - param2) ** 2).mean(axis=None) gradient = param2 - param1 return loss,gradient Blurred_Img=[] Sharp_Img=[] level1=convolution(3, 64) f_1=level1.filter bias1=level1.bias print(f_1, bias1) level2=convolution(64, 64) f_2=level2.filter bias2=level2.bias level3=convolution(64, 64) f_3=level3.filter bias3=level3.bias
def op_kirsch(im): r = np.zeros(im.shape, dtype=float) for i in range(8): r = np.maximum(r, convolution.convolution(im, kirschs[i])) return r
import convolution as conv import numpy as np import cv2 import time import sys import os dir_path = os.path.dirname(os.path.realpath(__file__)) img = cv2.imread(dir_path + '/../input/input-p1-2-1-0.png', 1) if img is None: print("Image not found.") sys.exit() #Kernel 3x3 edge detection msk = np.array([[-1, -1, -1], [-1, 8, -1], [-1, -1, -1]]) start_time = time.time() img_conv = conv.convolution(img, msk) print("A 3x3 mask took %s seconds in our convolution function" % round(time.time() - start_time, 4)) cv2.imwrite(dir_path + '/../output/output-p1-2-1-0.png', img_conv) start_time = time.time() img_conv_opencv = cv2.filter2D(img, -1, msk) print("A 3x3 mask took %s seconds in OpenCV filter" % round(time.time() - start_time, 4)) #Kernel 7x7 box blur msk = np.full((7, 7), 1 / (7 * 7)) start_time = time.time() img_conv = conv.convolution(img, msk) print("A 7x7 mask took %s seconds in our convolution function" % round(time.time() - start_time, 4)) cv2.imwrite(dir_path + '/../output/output-p1-2-1-1.png', img_conv)
# Metodos para imprimir los tatos def output(self, text): self.scrolledtext1.insert("1.0", text) print(text) return 0 if __name__ == "__main__": #Se manda a llamar la interfaz para buscar la imagen image = Procesar_imagen() #Se guarda el atributo "image_name" de la clase "Principal" en la variable "image_name" image_name = image.image_name # se saca la matriz de la imagen img = cv2.imread(image_name) # Hacer kernel gausiano kernel_gauss = gaussian_blur(9) # Hacer convolusion img = convolution(img, kernel_gauss, True) output = Output("Gaussian Blur\n" + "Shape:" + str(img.shape[0]) + " X " + str(img.shape[1])) # Aplicar Line Detection img = line_detection(img, verbose=True) output = Output("Line Detection\n" + "Shape:" + str(img.shape[0]) + " X " + str(img.shape[1])) # Aplicar laplacian img = laplacian(img, verbose=True) output = Output("Laplacian\n" + "Shape:" + str(img.shape[0]) + " X " + str(img.shape[1]))