def convolve2d(img, kernel): """Convolves a given image and a given kernel. Steps: (1) flips the either the img or the kernel. (2) pads the img or the flipped img. this step handles pixels along the border of the img, and makes sure that the output img is of the same size as the input image. (3) applies the flipped kernel to the image or the kernel to the flipped image, using nested for loop. Args: img: nested list (int), image. kernel: nested list (int), kernel. Returns: img_conv: nested list (int), image. """ # TODO: implement this function. # raise NotImplementedError flipped_img = utils.flip2d(img) convoluted_img = copy.deepcopy(flipped_img) padded_img = utils.zero_pad(convoluted_img, 1, 1) for i in range(len(convoluted_img)): for j in range(len(convoluted_img[0])): convoluted_img[i][j] = utils.add_matrix( utils.elementwise_mul( utils.crop(padded_img, i, i + 3, j, j + 3), kernel)) return utils.flip2d(convoluted_img)
def convolve2d(img, kernel): """Convolves a given image and a given kernel. Steps: (1) flips either the img or the kernel. (2) pads the img or the flipped img. this step handles pixels along the border of the img, and makes sure that the output img is of the same size as the input image. (3) applies the flipped kernel to the image or the kernel to the flipped image, using nested for loop. Args: img: nested list (int), image. kernel: nested list (int), kernel. Returns: img_conv: nested list (int), image. """ # TODO: implement this function. flipped_img = utils.flip2d(img) padded_img = utils.zero_pad(flipped_img, 1, 1) img_conv = np.zeros((len(img), len(img[0]))) for i in range(1, len(padded_img)-2): for j in range(1, len(padded_img[0])-2): img_sec = utils.crop(padded_img, i-1, i+2, j-1, j+2) prod = utils.elementwise_mul(kernel, img_sec) res = 0 for g in range(len(prod)): for h in range(len(prod[0])): res += prod[g][h] img_conv[i-1][j-1] = res img_conv = utils.flip2d(img_conv) # raise NotImplementedError return img_conv
def convolve2d(img, kernel): """Convolves a given image and a given kernel. Steps: (1) flips the kernel (2) pads the image # IMPORTANT this step handles pixels along the border of the image, and ensures that the output image is of the same size as the input image (3) calucates the convolved image using nested for loop Args: img: nested list (int), image. kernel: nested list (int), kernel. Returns: img_conv: nested list (int), convolved image. """ ### Creating a output buffer ###\ # output = np.zeros_like(img) ### Padding the image with zeros on all sides ### padding_width = 1 image_array = np.array(utils.zero_pad(img, padding_width, padding_width)) # image_shape = {'width': len(image_array[0]), 'height': len(image_array)} ''' Flattening and flipping the kernel flattening the kernel so that I can perform linear convolution operation(on 1D array) on the image ''' # kernel = np.array(kernel).flatten()[::-1] # for h in range(image_shape['height']-2): # for w in range(image_shape['width']-2): # a = image_array[h:h+3,w:w+3].flatten() # # Performing linear convolution operation on image with kernel # sum = np.sum(kernel * a, dtype=np.uint8) # output[h][w] = sum # for h in range(image_shape['height']-2): # for w in range(image_shape['width']-2): # subImg = image_array[h:h+3,w:w+3] # b = utils.elementwise_mul(subImg,flip_kernel) # ### Performing linear convolution operation on image with kernel ### # output[h][w] = np.sum(b, dtype=np.uint8) output = [] flip_kernel = utils.flip2d(kernel) for h in range(len(img) - 2): w_op = [] for w in range(len(img[0]) - 2): sum_img = 0 for k in range(len(flip_kernel)): for l in range(len(flip_kernel[0])): sum_img += img[h + k][w + l] * flip_kernel[k][l] w_op.append(sum_img) output.append(w_op) return output
def convolve2d(img, kernel): """Convolves a given image and a given kernel. Steps: (1) flips the kernel (2) pads the image # IMPORTANT this step handles pixels along the border of the image, and ensures that the output image is of the same size as the input image (3) calucates the convolved image using nested for loop Args: img: nested list (int), image. kernel: nested list (int), kernel. Returns: img_conv: nested list (int), convolved image. """ # TODO: implement this function. flipped_kernel = utils.flip2d(kernel) pad_size = int((len(kernel) - 1) / 2) padded_img = utils.zero_pad(img, pad_size, pad_size) filtered_img = copy.deepcopy(img) for i, row in enumerate(img): for j, pix in enumerate(row): patch = utils.crop(padded_img, i, i + 2 * pad_size + 1, j, j + 2 * pad_size + 1) patch = utils.elementwise_mul(patch, kernel) filtered_img[i][j] = sum([sum(l) for l in patch]) return filtered_img
def convolve2d(img, kernel): """Convolves a given image and a given kernel. Steps: (1) flips the kernel (2) pads the image # IMPORTANT this step handles pixels along the border of the image, and ensures that the output image is of the same size as the input image (3) calucates the convolved image using nested for loop Args: img: nested list (int), image. kernel: nested list (int), kernel. Returns: img_conv: nested list (int), convolved image. """ # TODO: implement this function. kl = len(kernel) pad = int(len(kernel) / 2) kernel = utils.flip2d(kernel) img_padded = utils.zero_pad(img, pad, pad) for x, row in enumerate(img): for y, num in enumerate(row): if (x < len(img[0]) - (round(len(kernel) / 2)) or y < len(img) - (round(len(kernel) / 2))): imgfoc = utils.elementwise_mul( kernel, utils.crop(img_padded, x, x + kl, y, y + kl)) sumele = 0 for i in range(len(imgfoc)): sumele += sum(subl[i] for subl in imgfoc) img[x][y] = sumele return img raise NotImplementedError
def convolve2d(img, kernel): """Convolves a given image and a given kernel. Steps: (1) flips the either the img or the kernel. (2) pads the img or the flipped img. this step handles pixels along the border of the img, and makes sure that the output img is of the same size as the input image. (3) applies the flipped kernel to the image or the kernel to the flipped image, using nested for loop. Args: img: nested list (int), image. kernel: nested list (int), kernel. Returns: img_conv: nested list (int), image. """ # TODO: implement this function. img_conv = [[0 for i in range(len(img[0]))] for j in range(len(img))] flipped_kernel = utils.flip2d(kernel) padded_img = utils.zero_pad(img, 1, 1) #Padding = (size of kernel - 1) / 2 neighbors = [(0, 0), (0, 1), (0, -1), (1, 0), (-1, 0), (1, 1), (1, -1), (-1, 1), (-1, -1)] for r in range(1, len(padded_img) - 1): for c in range(1, len(padded_img[0]) - 1): for _r, _c in neighbors: img_conv[r - 1][c - 1] += padded_img[r + _r][ c + _c] * flipped_kernel[1 + _r][1 + _c] #raise NotImplementedError return img_conv
def convolve2d(img, kernel): """Convolves a given image and a given kernel. Steps: (1) flips the either the img or the kernel. (2) pads the img or the flipped img. this step handles pixels along the border of the img, and makes sure that the output img is of the same size as the input image. (3) applies the flipped kernel to the image or the kernel to the flipped image, using nested for loop. Args: img: nested list (int), image. kernel: nested list (int), kernel. Returns: img_conv: nested list (int), image. """ # TODO: implement this function. kernel = utils.flip2d(kernel) img = zero_pad(img) height = len(img) width = len(img[0]) img_conv = [] for i in range(1, height - 1): row = [] for j in range(1, width - 1): total = 0 for p in range(3): for q in range(3): total += (img[i - 1 + p][j - 1 + q] * kernel[p][q]) row.append(total) img_conv.append(row) #raise NotImplementedError return img_conv
def convolve2d(img, kernel): """Convolves a given image and a given kernel. Steps: (1) flips the either the img or the kernel. (2) pads the img or the flipped img. this step handles pixels along the border of the img, and makes sure that the output img is of the same size as the input image. (3) applies the flipped kernel to the image or the kernel to the flipped image, using nested for loop. Args: img: nested list (int), image. kernel: nested list (int), kernel. Returns: img_conv: nested list (int), image. """ # TODO: implement this function. # raise NotImplementedError kernel_flip = utils.flip2d(kernel) img_pad = utils.zero_pad(img,1,1) kernel_row = len(kernel) kernel_col = len(kernel[0]) # img_conv = np.zeros(np.shape(img_pad)) image_ = copy.deepcopy(img_pad) # print(kernel_flip_y) # for row_index,row_value in enumerate(img_pad[1:-1]): # for col_index, col_value in enumerate(row_value[1:-1]): # sum_ = 0 # for i in range(-1,2): # for j in range(-1,2): # sum_ += img_pad[row_index+i][col_index+j]*kernel_flip_y[1+i][1+j] # image_[row_index][col_index]= sum_ for row_index, row_value in enumerate(img_pad[:-2]): for col_index,col_val in enumerate(row_value[:-2]): img_temp = utils.crop(img_pad,row_index,(row_index+kernel_row),col_index,(col_index+kernel_col)) imp_temp_1 = utils.elementwise_mul(img_temp,kernel) img_conv_sum = pixel_conv_sum(imp_temp_1) image_[row_index+1][col_index+1] = img_conv_sum img_conv = image_ img_conv = utils.crop(img_conv,1,257,1,257) # print(f'The Type for convo is {type(img_conv)}') return img_conv
def convolve2d(img, kernel): """Convolves a given image and a given kernel. Steps: (1) flips either the img or the kernel. (2) pads the img or the flipped img. This step handles pixels along the border of the img, and makes sure that the output img is of the same size as the input image. (3) applies the flipped kernel to the image or the kernel to the flipped image,using nested for loop. Args: img : nested list (int), image. kernel: nested list (int), kernel. Returns: img_conv: nested list (int), image. """ # TODO: DONE padding_layer = len(kernel) // 2 kernel = utils.flip2d(kernel) # flip the kernel img = utils.zero_pad(img, padding_layer, padding_layer) # padding the image row_count = len(img) col_count = len(img[0]) # output image having same size as the input image img_conv = [] zeros = [0] * (col_count - 2 * padding_layer) for i in range(row_count - 2 * padding_layer): img_conv.insert(0, [0 for value in enumerate(zeros)]) kernel_h = len(kernel) kernel_w = len(kernel[0]) for i in range(row_count - kernel_h + 1): for j in range(col_count - kernel_w + 1): # multiplying the cropped portion with kernel mult_result = utils.elementwise_mul( utils.crop(img, i, i + kernel_h, j, j + kernel_w), kernel) sum = 0 for p in range(len(mult_result)): for q in range(len(mult_result[p])): sum += mult_result[p][q] img_conv[i][j] = sum #raise NotImplementedError return img_conv
def convolve2d(img, kernel): """Convolves a given image and a given kernel. Steps: (1) flips the kernel (2) pads the image # IMPORTANT this step handles pixels along the border of the image, and ensures that the output image is of the same size as the input image (3) calculates the convolved image using nested for loop Args: img: nested list (int), image. kernel: nested list (int), kernel. Returns: img_conv: nested list (int), convolved image. """ """" Step 1: Flip the kernel """ "" utils.flip2d(kernel) """" Step 2: Pad the image """ "" padded_img = utils.zero_pad(img, 1, 1) """" Step 3: Calculate convolved image using nested for loop. """ "" # nested for loops to iterate through image to select each pixel for i in range(len(img)): for j in range(len(img[0])): pixel_val = 0 # iterate through kernel to compute sum for k in range(len(kernel)): for l in range(len(kernel[0])): pixel = padded_img[i + k][j + l] pixel_val = pixel_val + (pixel * kernel[k][l]) img[i][j] = pixel_val return img # TODO: implement this function. raise NotImplementedError
def convolve2d(img, kernel): """Convolves a given image and a given kernel. Steps: (1) flips the kernel (2) pads the image # IMPORTANT this step handles pixels along the border of the image, and ensures that the output image is of the same size as the input image (3) calucates the convolved image using nested for loop Args: img: nested list (int), image. kernel: nested list (int), kernel. Returns: img_conv: nested list (int), convolved image. """ # TODO: implement this function. # Flipping the kernel to x-axis and then y-axis flip_kernel = utils.flip2d(kernel, axis=None) # Checking the kernel matrix dimension kernel_height = len(flip_kernel) kernel_width = len(flip_kernel[0]) pwx = (kernel_height - 1) // 2 pwy = (kernel_width - 1) // 2 # Padding the image with zero padding img_padding = utils.zero_pad(img, pwx, pwy) # Checking the padded image dimension img_padding_h = len(img_padding) img_padding_w = len(img_padding[0]) # Creating a copy of input image output = copy.deepcopy(img) for x in range(img_padding_h - (pwx * 2)): for y in range(img_padding_w - (pwx * 2)): # Cropping the image as kernel dimension crop_img = utils.crop(img_padding, x, x + kernel_height, y, y + kernel_width) # Multiplying the elements of Cropped image matrix and kernel matrix img_mult = utils.elementwise_mul(crop_img, flip_kernel) sum_elem = 0 for m in range(len(img_mult)): for n in range(len(img_mult[0])): # Adding the matrix elements sum_elem = sum_elem + img_mult[m][n] output[x][y] = sum_elem return output
def convolve2d(img, kernel): """Convolves a given image and a given kernel. Steps: (1) flips the kernel (2) pads the image # IMPORTANT this step handles pixels along the border of the image, and ensures that the output image is of the same size as the input image (3) calucates the convolved image using nested for loop Args: img: nested list (int), image. kernel: nested list (int), kernel. Returns: img_conv: nested list (int), convolved image. """ # TODO: implement this function. #raise NotImplementedError # flip kernel = utils.flip2d(kernel) ######################### #padding pr = int((len(kernel) - 1) / 2) pc = int((len(kernel[0]) - 1) / 2) img = utils.zero_pad(img, pr, pc) ########################### #cnn temp = [] dotp = [] k_flat = flat(kernel) new = [] img_conv = [] for k in range(len(img) - len(kernel) + 1): for l in range(len(img[0]) - len(kernel[0]) + 1): for i in range(len(kernel)): for j in range(len(kernel[0])): temp.append(img[i + k][j + l]) dotp = dotpro(temp, k_flat) temp = [] new.append(dotp) img_conv.append(new) new = [] return img_conv
def convolve2d(img, kernel): """Convolves a given image and a given kernel. Steps: (1) flips the kernel (2) pads the image # IMPORTANT this step handles pixels along the border of the image, and ensures that the output image is of the same size as the input image (3) calucates the convolved image using nested for loop Args: img: nested list (int), image. kernel: nested list (int), kernel. Returns: img_conv: nested list (int), convolved image. """ # TODO: implement this function. flipped_kernel=utils.flip2d(kernel) #number of row and cols padding will, be equal to length of rows and columns minus 1 respectively padding_rows=len(kernel)-1 padding_cols=len(kernel[0])-1 padded_image=utils.zero_pad(img,padding_rows,padding_cols) #copied the padded image to a temporary variable to modify the convolution changes temp_array=copy.deepcopy(padded_image) for i in range(len(padded_image)-1): for j in range(len(padded_image[0])-1): #created patches of each matrices which overlap with kernel xmin=i xmax=i+len(flipped_kernel) ymin=j ymax=j+len(flipped_kernel[0]) patch = padded_image[xmin: xmax] patch = [row[ymin: ymax] for row in patch] #multiplied each element of patch with corresponding element of flipped kernel and calculated the end summation multiplied=utils.elementwise_mul(patch,flipped_kernel) summation=0 for m in range(len(multiplied)): for n in range(len(multiplied[0])): summation+=multiplied[m][n] temp_array[i][j]=summation #set min and max x and y for croping the padded image min_x=padding_rows-1 max_x=len(padded_image)-(padding_rows+1) min_y=padding_cols-1 max_y=len(padded_image[0])-(padding_cols+1) temp_array=utils.crop(temp_array,min_x,max_x,min_y,max_y) return temp_array
def convolve2d(img, kernel): """Convolves a given image and a given kernel. Steps: (1) flips the either the img or the kernel. (2) pads the img or the flipped img. this step handles pixels along the border of the img, and makes sure that the output img is of the same size as the input image. (3) applies the flipped kernel to the image or the kernel to the flipped image, using nested for loop. Args: img: nested list (int), image. kernel: nested list (int), kernel. Returns: img_conv: nested list (int), image. """ # TODO: implement this function. row_zero = len(img) pixel_zero = len(img[0]) width = pixel_zero height = row_zero dim = (height, width) pad_len = 1 kernel_dim = 3 img_conv = np.zeros(dim) # print(str(len(img_conv)) + str(len(img_conv[0]))) kernel_flip = utils.flip2d(kernel) pad_img = utils.zero_pad(img, pad_len, pad_len) i_conv = 0 for i in range(1, row_zero + 1): j_conv = 0 for j in range(1, pixel_zero + 1): for k in range(0, kernel_dim): for l in range(0, kernel_dim): x = i + k - 1 y = j + l - 1 img_conv[i_conv][j_conv] += (pad_img[x][y] * kernel_flip[k][l]) j_conv += 1 i_conv += 1 return img_conv
def convolve2d(img, kernel): """Convolves a given image and a given kernel. Steps: (1) flips the kernel (2) pads the image # IMPORTANT this step handles pixels along the border of the image, and ensures that the output image is of the same size as the input image (3) calucates the convolved image using nested for loop Args: img: nested list (int), image. kernel: nested list (int), kernel. Returns: img_conv: nested list (int), convolved image. """ # TODO: implement this function. # Initialization and Primary Calculation img_height = len(img) kernel_height = len(kernel) kernel_width = len(kernel[0]) pwx = (kernel_height - 1) // 2 pwy = (kernel_height - 1) // 2 flip_kernel = utils.flip2d( kernel, axis=None) #flipping the kernel along x-axis and y-axis Zero_padded_image = utils.zero_pad(img, pwx, pwy) #Image with zero padding Zero_padded_image_h = len(Zero_padded_image) #Height of zero padded image Zero_padded_image_w = len( Zero_padded_image[0]) #Width of zero padded image img_res = copy.deepcopy(img) for x in range(Zero_padded_image_h - (pwx * 2)): for y in range(Zero_padded_image_w - (pwy * 2)): img_crop = utils.crop( Zero_padded_image, x, x + kernel_height, y, y + kernel_width ) #Cropping the zero padded image with flipped kernel mult_element = utils.elementwise_mul(img_crop, flip_kernel) sum_element = 0 for i in range(len(mult_element)): for j in range(len(mult_element[0])): sum_element = sum_element + mult_element[i][j] img_res[x][y] = sum_element #Creating output image return img_res
def convolve2d(img, kernel): """Convolves a given image and a given kernel. Steps: (1) flips the either the img or the kernel. (2) pads the img or the flipped img. this step handles pixels along the border of the img, and makes sure that the output img is of the same size as the input image. (3) applies the flipped kernel to the image or the kernel to the flipped image, using nested for loop. Args: img: nested list (int), image. kernel: nested list (int), kernel. Returns: img_conv: nested list (int), image. """ #print(len(img),len(img[0])) pwx = 1 pwy = 1 #print(kernel) kernel = utils.flip2d(kernel, None) #print(kernel) img = utils.zero_pad(img, pwx, pwy) #print(len(img),len(img[0])) img_conv = copy.deepcopy(img) for i in range(1, len(img) - 1): for j in range(1, len(img[0]) - 1): img_inter = utils.elementwise_mul( utils.crop(img, i - 1, i + 2, j - 1, j + 2), kernel) #print(img_inter) sum = 0 for k in [0, 1, 2]: for l in [0, 1, 2]: sum += img_inter[k][l] #print(sum) img_conv[i][j] = sum img_conv = utils.crop(img_conv, 1, len(img_conv) - 1, 1, len(img_conv[0]) - 1) #print(len(img_conv),len(img_conv[0])) # TODO: implement this function. #raise NotImplementedError return img_conv
def convolve2d(img, kernel): """Convolves a given image and a given kernel. Steps: (1) flips the kernel (2) pads the image # IMPORTANT this step handles pixels along the border of the image, and ensures that the output image is of the same size as the input image (3) calculates the convolved image using nested for loop Args: img: nested list (int), image. kernel: nested list (int), kernel. Returns: img_conv: nested list (int), convolved image. """ # flips the kernel flipped_kernel = utils.flip2d(kernel) # using 2k+1 form to calc the value of k k = int((len(kernel) - 1) / 2) # padding the image padded_img = utils.zero_pad(img, k, k) # TODO:implement this function. # implementing convolution # master loop for img array for row in range(0, len(img)): for col in range(0, len(img[0])): # creating the convolution matrix for applying the filter from img convolve_img_matrix = utils.crop(padded_img, row, row + len(kernel), col, col + len(kernel[0])) convolve_img_matrix_mul_kernel = utils.elementwise_mul( convolve_img_matrix, flipped_kernel) # calculating the convoluted value for the pixel convoluted_value = 0 for val_list in convolve_img_matrix_mul_kernel: for val in val_list: convoluted_value = convoluted_value + val # replacing the value in padded_img img[row][col] = convoluted_value return img
def convolve2d(img, kernel): """Convolves a given image and a given kernel. Steps: (1) flips the either the img or the kernel. (2) pads the img or the flipped img. this step handles pixels along the border of the img, and makes sure that the output img is of the same size as the input image. (3) applies the flipped kernel to the image or the kernel to the flipped image, using nested for loop. Args: img: nested list (int), image. kernel: nested list (int), kernel. Returns: img_conv: nested list (int), image. """ kernel = utils.flip2d(kernel) img = utils.zero_pad(img, 1, 1) ConvolutedImg = [] m = 0 n = 0 sum = 0 for i in range(0, len(img) - 2): row = [] for j in range(0, len(img) - 2): m = 0 for k in range(i, i + 3): for l in range(j, j + 3): sum = sum + img[k][l] * kernel[m][n] n = n + 1 n = 0 m = m + 1 row.append(sum) sum = 0 ConvolutedImg.append(row) row = [] # TODO: implement this function. #raise NotImplementedError print("convoluted") print(np.shape(ConvolutedImg)) return ConvolutedImg
def convolve2d(img, kernel): """Convolves a given image and a given kernel. Steps: (1) flips the kernel (2) pads the image # IMPORTANT this step handles pixels along the border of the image, and ensures that the output image is of the same size as the input image (3) calucates the convolved image using nested for loop Args: img: nested list (int), image. kernel: nested list (int), kernel. Returns: img_conv: nested list (int), convolved image. """ # TODO: implement this function. # raise NotImplementedError rows = (len(img)) cols = (len(img[0])) """flipping kernel""" kernel = utils.flip2d(kernel) """padding the image""" img = utils.zero_pad(img, 1, 1) """convolution""" img_conv = [] for i in range(rows): each_row = [] for j in range(cols): dot_product = 0 for m in range(i, i + len(kernel)): for n in range(j, j + len(kernel[0])): dot_product += img[m][n] * kernel[m - i][n - j] each_row.append(dot_product) img_conv.append(each_row) return img_conv
def convolve2d(img, kernel): """Convolves a given image and a given kernel. """ row = len(img) col = len(img[0]) flipped_kernel = utils.flip2d(kernel) padded_img = utils.zero_pad(img, 1, 1) rowpad = len(padded_img) colpad = len(padded_img[0]) img_conv = np.zeros(shape=(rowpad, colpad)) subImg = np.zeros(shape=(3, 3)) for i in range(0, rowpad-2): for j in range(0, colpad-2): subImg = imageSubPart(padded_img, i, j) newval = filterSobel(subImg, flipped_kernel) """Write normalize call""" img_conv[i, j] = newval return img_conv
def detect_edges(img, kernel, norm=True): """Detects edges using a given kernel. Args: img: nested list (int), image. kernel: nested list (int), kernel used to detect edges. norm (bool): whether to normalize the image or not. Returns: img_edge: nested list (int), image containing detected edges. """ # TODO: detect edges using convolve2d and normalize the image containing detected edges using normalize. # img_edges = normalize(img) img_edges = utils.flip2d(convolve2d(img,kernel)) if norm == True: img_edges = normalize(img_edges) # detect_edges = convolve2d(img,kernel) # img_edges = normalize(detect_edges) # raise NotImplementedError return img_edges
def convolve2d(img, kernel): """Convolves a given image and a given kernel. Steps: (1) flips the kernel (2) pads the image # IMPORTANT this step handles pixels along the border of the image, and ensures that the output image is of the same size as the input image (3) calucates the convolved image using nested for loop Args: img: nested list (int), image. kernel: nested list (int), kernel. Returns: img_conv: nested list (int), convolved image. """ kernel = utils.flip2d(kernel, axis=None) px = int(len(kernel) / 2) py = int(len(kernel[0]) / 2) img = utils.zero_pad(img, px, py) m = len(kernel) n = len(kernel[0]) x = len(img) y = len(img[0]) x = x - m + 1 y = y - n + 1 int_img = [] for i in range(x): for j in range(y): a = [temp[j:j + n] for temp in img[i:i + m]] int_img.append(a) final = [] for k in int_img: b = utils.elementwise_mul(k, kernel) total = 0 for abc in b: for xyz in abc: total += xyz final.append(total) img_conv = [final[i:i + y] for i in range(0, len(final), y)] return img_conv
def convolve2d(img, kernel): """Convolves a given image and a given kernel. Steps: (1) flips the kernel (2) pads the image # IMPORTANT this step handles pixels along the border of the image, and ensures that the output image is of the same size as the input image (3) calucates the convolved image using nested for loop Args: img: nested list (int), image. kernel: nested list (int), kernel. Returns: img_conv: nested list (int), convolved image. """ # TODO: implement this function. # raise NotImplementedError d_img = copy.deepcopy(img) # Flip the Kernel f_ker = utils.flip2d(kernel) # Add padding of 1 for a 3x3 template p_img = utils.zero_pad(img, pwx=1, pwy=1) # Cropping a 3x3 template and performing element wise multiplication. # Taking the sum of the multiplied values and inserting the sum in the middle most cell of the image. print("length:", len(img)) print("height:", len(img[0])) for r in range(len(img)): for c in range(len(img[0])): c_img = utils.crop(p_img, r, r + 3, c, c + 3) m_img = utils.elementwise_mul(c_img, kernel) sum_val = sum([i for s in m_img for i in s]) d_img[r][c] = sum_val return d_img
def convolve2d(img, kernel): """Convolves a given image and a given kernel. Steps: (1) flips the either the img or the kernel. (2) pads the img or the flipped img. this step handles pixels along the border of the img, and makes sure that the output img is of the same size as the input image. (3) applies the flipped kernel to the image or the kernel to the flipped image, using nested for loop. Args: img: nested list (int), image. kernel: nested list (int), kernel. Returns: img_conv: nested list (int), image. """ # TODO: implement this function. flipped_kernel = utils.flip2d(kernel) padded_img = utils.zero_pad(img, 1, 1) temp = [] convolved_img = [] for i in range(len(img)): for j in range(len(img[i])): cropped_img = utils.crop(padded_img, i, i+3, j, j+3) mul_op = utils.elementwise_mul(cropped_img, flipped_kernel) value = sum([sum(a) for a in mul_op]) temp.append(value) convolved_img.append(temp) temp = [] # raise NotImplementedError return convolved_img
def convolve2d(img, kernel): """Convolves a given image and a given kernel. Steps: (1) flips the either the img or the kernel. (2) pads the img or the flipped img. this step handles pixels along the border of the img, and makes sure that the output img is of the same size as the input image. (3) applies the flipped kernel to the image or the kernel to the flipped image, using nested for loop. Args: img: nested list (int), image. kernel: nested list (int), kernel. Returns: img_conv: nested list (int), image. """ # TODO: implement this function. flipped_k = utils.flip2d(kernel, axis=None) img_h = len(img) img_w = len(img[0]) kernel_row = len(kernel) kernel_column = len(kernel[0]) #kernel size is 3,given in line 30-35 img_padded = utils.zero_pad(img, 1, 1) img_conv = [[0 for row in range(img_w)] for column in range(img_h)] for i in range(1, img_h - 2): for j in range(1, img_w - 2): sum = 0 for m in range(kernel_row): for n in range(kernel_column): sum = sum + (img_padded[i + m][j + n] * flipped_k[m][n]) img_conv[i + 1][j + 1] = sum #Center of the kernel here is (i+1)and (j+1) # raise NotImplementedError return img_conv
def convolve2d(img, kernel): """Convolves a given image and a given kernel. Steps: (1) flips the kernel (2) pads the image # IMPORTANT this step handles pixels along the border of the image, and ensures that the output image is of the same size as the input image (3) calucates the convolved image using nested for loop Args: img: nested list (int), image. kernel: nested list (int), kernel. Returns: img_conv: nested list (int), convolved image. """ # TODO: implement this function. img_h = len(img) img_w = len(img[0]) padded_img = utils.zero_pad(img, 1, 1) # Pads img with zero at the border. new_img = [ [0 for x in range(img_w)] for y in range(img_h) ] # Create a new two-dimensional list to store the calculated values kernel = utils.flip2d(kernel) # flips the kernel kernel_h = len(kernel) kernel_w = len(kernel[0]) for m in range(img_h): for n in range(img_w): s = 0 for x in range(kernel_h): for y in range(kernel_w): s = s + kernel[x][y] * padded_img[m + x][n + y] new_img[m][n] = s return new_img raise NotImplementedError
def convolve2d(img, kernel): """Convolves a given image and a given kernel. Steps: (1) flips the either the img or the kernel. (2) pads the img or the flipped img. this step handles pixels along the border of the img, and makes sure that the output img is of the same size as the input image. (3) applies the flipped kernel to the image or the kernel to the flipped image, using nested for loop. Args: img: nested list (int), image. kernel: nested list (int), kernel. Returns: img_conv: nested list (int), image. """ # TODO: implement this function. #flippedAndPadded_img=u.zero_pad(u.flip_x(img), 1, 1) #length=len(flippedAndPadded_img)-len(kernel)+1 #print("Length is"+str(length)) #result=np.zeros((length, length)) #for i in range(length): # for j in range(length): # result[i][j]=multiply_add(u.crop(flippedAndPadded_img,i,i+3,j,j+3),kernel) kernel = u.flip2d(kernel) zeropadded_Image = u.zero_pad(img, 1, 1) img_conv = copy.deepcopy(img) for m, row in enumerate(img): for i, pixel in enumerate(row): cp = u.crop(zeropadded_Image, m, m + 3, i, i + 3) mulValue = u.elementwise_mul(cp, kernel) img_conv[m][i] = task2.addAllElements(mulValue) return img_conv
def convolve2d(img, kernel): """ Convolves a given image and a given kernel. Steps: (1) flips the either the img or the kernel. (2) pads the img or the flipped img. this step handles pixels along the border of the img, and makes sure that the output img is of the same size as the input image. (3) applies the flipped kernel to the image or the kernel to the flipped image, using nested for loop. Args: img: nested list (int), image. kernel: nested list (int), kernel. Returns: img_conv: nested list (int), image. """ # Image dimensions m, n = len(img), len(img[0]) # Filter dimensions k, l = len(kernel), len(kernel[0]) flipped_filter = utils.flip2d(kernel) img_padded = utils.zero_pad(img, 1, 1) img_conv = [[0 for _ in range(n)] for _ in range(m)] for i in range(m): for j in range(n): img_ = utils.crop(img_padded, i, i + k, j, j + l) mul = utils.elementwise_mul(img_, flipped_filter) img_conv[i][j] = sum([sum(x) for x in mul]) * 1.0 return img_conv
def convolve2d(img, kernel): """Convolves a given image and a given kernel. Steps: (1) flips the kernel (2) pads the image # IMPORTANT this step handles pixels along the border of the image, and ensures that the output image is of the same size as the input image (3) calucates the convolved image using nested for loop Args: img: nested list (int), image. kernel: nested list (int), kernel. Returns: img_conv: nested list (int), convolved image. """ # Flip Kernel flipped_kernel = utils.flip2d(kernel) # Pad image kernelx = len(kernel) kernely = len(kernel[0]) pad_amt_x = int(kernelx / 2) pad_amt_y = int(kernely / 2) padded_img = utils.zero_pad(img, pad_amt_x, pad_amt_y) # Convolve image with kernel convolved_img = copy.deepcopy(img) for i in range(len(img)): for j in range(len(img[0])): weighted_sum = 0 for ki in range(kernelx): for kj in range(kernely): weighted_sum += flipped_kernel[ki][kj] * padded_img[i + ki][j + kj] convolved_img[i][j] = weighted_sum return convolved_img
def convolve2d(img, kernel): """Convolves a given image and a given kernel. Steps: (1) flips the kernel (2) pads the image # IMPORTANT this step handles pixels along the border of the image, and ensures that the output image is of the same size as the input image (3) calucates the convolved image using nested for loop Args: img: nested list (int), image. kernel: nested list (int), kernel. Returns: img_conv: nested list (int), convolved image. """ # TODO: implement this function. # raise NotImplementedError imgSizeX = len(img) imgSizeY = len(img[0]) kernelSizeX = len(kernel) kernelSizeY = len(kernel[0]) paddingSizeX = kernelSizeX//2 paddingSizeY = kernelSizeY//2 flippedKernel = utils.flip2d(kernel) paddedImg = utils.zero_pad(img, paddingSizeX, paddingSizeY) convolvedImg = [[0 for x in range(imgSizeY)] for y in range(imgSizeX)] for i in range(imgSizeX): for j in range(imgSizeY): for u in range(kernelSizeX): for v in range(kernelSizeY): convolvedImg[i][j] += flippedKernel[u][v]*paddedImg[i+u][j+v] return convolvedImg