def smoothing_btn_func(): global temp,mod,HSI_arr if(mode.get()==1): #HSI temp=Image.fromarray(np.uint8(HSI_arr)) else: temp=mod #RGB temp = temp.filter(ImageFilter.Kernel((5,5),(1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1))) #kernel refresh()
def tranfun(self, image): image = get_pil_image(image) angle=random.randint(0,self.angle) M = cv2.getRotationMatrix2D((self.degree / 2, self.degree / 2), angle, 1) motion_blur_kernel = np.diag(np.ones(self.degree)) motion_blur_kernel = cv2.warpAffine(motion_blur_kernel, M, (self.degree, self.degree)) motion_blur_kernel = motion_blur_kernel / self.degree image = image.filter(ImageFilter.Kernel(size=(self.degree,self.degree),kernel=motion_blur_kernel.reshape(-1))) return image
def sharp_func(val): global mod, temp val = int(val) temptemp = mod.copy() #same as sharp func for i in range(val): temptemp = temptemp.filter( ImageFilter.Kernel((3, 3), (0, -1, 0, -1, 5, -1, 0, -1, 0))) temp = temptemp refresh()
def smooth_func(val): global mod, temp val = int(val) temptemp = mod.copy() #iterate times for i in range(val): temptemp = temptemp.filter( ImageFilter.Kernel((3, 3), (1, 2, 1, 2, 4, 2, 1, 2, 1))) #filter temp = temptemp refresh()
def kernel1_image(im): size = (3, 3) kernel1 = [1, 1, 1, 1, -1, 1, -1, -1, -1] ker1 = ImageFilter.Kernel(size, kernel1, scale=None, offset=0) # plt.subplot(3, 4, 11) im11 = im.filter(ker1) plt.show(im11) plt.title("Custom Filter 1") plt.show()
def suavizado(): imagen_original = Image.open(fbi) tamaño = (3,3) a=1 coeficientes= [a, a, a, a, a, a, a, a, a] imagen_filtrada = imagen_original.filter(ImageFilter.Kernel(tamaño, coeficientes)) return imagen_original.show(),imagen_filtrada.show()
def test_consistency_5x5(self): im = Image.open("Tests/images/hopper.bmp") emboss = im.filter( ImageFilter.Kernel( (5, 5), (-1, -1, -1, -1, 0, -1, -1, -1, 0, 1, -1, -1, 0, 1, 1, -1, 0, 1, 1, 1, 0, 1, 1, 1, 1), 0.3)) self.assert_image_equal( emboss, Image.open("Tests/images/hopper_emboss_more.bmp"))
def vivid(self, image): # 선명하게 clear! mat = ImageFilter.Kernel( (3, 3), (0, -1 / 2, 0, -1 / 2, 3, -1 / 2, 0, -1 / 2, 0)) image = image.filter(mat) pixmap = QPixmap.fromImage((ImageQt.ImageQt(image))) pixmap.detach() return (image, pixmap) pass
def procesa_imagen(self, tam_matriz): if self.aplicacion.imagen != None: L = self.asigna_valores_filtro(tam_matriz) imgf = Image.fromarray(self.aplicacion.imagen) img_aux = imgf.filter(ImageFilter.Kernel(L[0], L[1], L[2])) self.aplicacion.imagen = numpy.asarray(img_aux) self.aplicacion.dibujar_img(self.aplicacion.imagen) self.desaparece_dialogo() self.aplicacion.actualiza_historial()
def kernel2_image(im): size = (3, 3) kernel2 = [1, 0, -1, 1, 0, -1, 0, 0, -1] ker2 = ImageFilter.Kernel(size, kernel2, sale=None, offset=0) plt.subplot(3, 5, 12) im12 = im.filter(ker2) plt.imshow(im12) plt.title("Custom Filter 2") plt.show()
def main(): image = Image.open('../lenna.png') image.show('Original') # Using kernels for blurring # The size of the kernel - can be 3x3 or 5x5 size = (3, 3) # The kernel itself kernel_matrix = (1, 1, 1, 1, 1, 1, 1, 1, 1) # The final convolved result for each pixel is divied by the scale argument # By default it is the sum of the kernel matrix weights. # In our case the sum is 9. Each pixel is a result of convolving # the neighbour pixels with the kernel matrix and then dividing it by 9. # In other words - it is the mean value of the 3x3 window for each pixel # thus resulting in a blurred image. kernel = ImageFilter.Kernel(size, kernel_matrix) blurred_image = image.filter(kernel) blurred_image.show('Blur') # Let's smooth the image kernel_matrix = (1, 1, 1, 1, 5, 1, 1, 1, 1) kernel = ImageFilter.Kernel(size, kernel_matrix) smooth_image = image.filter(kernel) smooth_image.show('Smooth') # Sharpening kernel_matrix = (-2, -2, -2, -2, 32, -2, -2, -2, -2) kernel = ImageFilter.Kernel(size, kernel_matrix, scale=16) sharpen_image = image.filter(kernel) sharpen_image.show('Sharpen') # Detail kernel_matrix = (0, -1, 0, -1, 10, -1, 0, -1, 0) kernel = ImageFilter.Kernel(size, kernel_matrix, scale=6) detail_image = image.filter(kernel) detail_image.show('Detail')
def process_image(self, url): image = self._get_image(url) image.filter(ImageFilter.SHARPEN) image = self._resize_image(image, 12) image.filter(ImageFilter.GaussianBlur(2)) image.filter(ImageFilter.SMOOTH) image.filter(ImageFilter.Kernel((3, 3), [1, 1, 1, 0, 0, 0, -1, -1, -1])) s = pytesseract.image_to_string(image) return self.normalize(s)
def auto_kernel(self, size): self.modal_window = Modal("Zdefiniuj maskę") self.modal_window.init_own_mask_modal(size) if self.modal_window.exec_(): self.kernel_vals = self.modal_window.button_nonsignal_confirm_exit( "unsharp") kernel_img = self.image.filter( ImageFilter.Kernel(self.kernel_vals[0], self.kernel_vals[1])) self.image = kernel_img self.loadImageFromPIX(self.image)
def kernelSmooth(sourceImagePath, targetImagePath): #13th function extra im = Image.open(sourceImagePath) new = im.copy() new = new.filter( ImageFilter.Kernel((3, 3), [1, 2, 1, 2, 4, 2, 1, 2, 1], 16)) if targetImagePath != "": new.save(targetImagePath) print("saved") else: return new
def readimg(): im= img.filter(ImageFilter.SMOOTH) im=img.filter(ImageFilter.Kernel((3,3),(1,1,1,0,0,0,2,0,2))) #im.show() (W,H)=im.size pixel=numpy.zeros([W,H,4]) for w in range(W): for h in range(H): pixel[w,h,(range(3))] = numpy.array(im.getpixel((w, h)) ) pixel[w,h,0:3]=sum(pixel[w,h,range(3)])/3 return pixel,img
def find_edges(img): #img: image name Filter = (-1, -1, -1, -1, 8, -1, -1, -1, -1) img = Image.open(img) img = img.convert("L") # Calculating Edges with Laplace Kernel final = img.filter(ImageFilter.Kernel((3, 3), Filter, 1, 0)) rgb_im = final.convert('RGB') matrix = np.array(rgb_im) #r, g, b = rgb_im.getpixel((1, 1)) return matrix
def run(): # Abrir a Imagem img1 = Image.open('images/originalNature.jpg') # Criar o Kernel (Sharpen) kernelS = ImageFilter.Kernel((3, 3), (0, -1, 0, -1, 5, -1, 0, -1, 0), 1, 0) # Aplicar o filtro na imagem img2 = img1.filter(kernelS) # Criar o Kernel (Blur kernelB = ImageFilter.Kernel( (3, 3), ((1 / 9), (1 / 9), (1 / 9), (1 / 9), (1 / 9), (1 / 9), (1 / 9), (1 / 9), (1 / 9)), 1, 0) # Aplicar o filtro na imagem img3 = img2.filter(kernelB) # Salvar as imagens img2.save('images/filtro_sharpen.jpg') img3.save('images/filtro_sharpen_mediana.jpg')
def Fauna(): # Abrindo uma imagem img = Image.open("Foto/Imagem.jpg") #Quebra em canais #Faz um gausiano em cada canal #Aumenta o brilho em azul e verde, diminui em vermelho #junta tudo r,g,b = img.split() #Gaussiano k = [1,2,1,2,4,2,1,2,1] filtro = ImageFilter.Kernel((3,3),k) r = r.filter(filtro) g = g.filter(filtro) b = b.filter(filtro) #Equalizando a imagem r = ImageOps.equalize(r) g = ImageOps.equalize(g) b = ImageOps.equalize(b) #Brilho ref=[] lut=[] for i in range(256): ref.append(i) val = i+50 if val>255: val=255 if val<0: val=0 lut.append(val) g = g.point(lut) b = b.point(lut) #Brilho ref=[] lut=[] for i in range(256): ref.append(i) val = i-50 if val>255: val=255 if val<0: val=0 lut.append(val) r = r.point(lut) img = Image.merge('RGB', (r, g, b)) img.save("Processadas/FiltroImagens.jpg") Fauna2.Fauna2()
def test_consistency_3x3(self): source = Image.open("Tests/images/hopper.bmp") reference = Image.open("Tests/images/hopper_emboss.bmp") kernel = ImageFilter.Kernel((3, 3), (-1, -1, 0, -1, 0, 1, 0, 1, 1), .3) source = source.split() * 2 reference = reference.split() * 2 for mode in ['L', 'LA', 'RGB', 'CMYK']: self.assert_image_equal( Image.merge(mode, source[:len(mode)]).filter(kernel), Image.merge(mode, reference[:len(mode)]), )
def filtro02(): # Abrir a Imagem img1 = Image.open('images/originalFachada.jpg') # Criar o Kernel kernel = ImageFilter.Kernel((3, 3), (0, 1, 0, 1, -4, 1, 0, 1, 0), 1, 0) # Aplicar o filtro na imagem img2 = img1.filter(kernel) # Salvar a imagem img2.save('images/filtro_2.jpg')
def random_blur(img, prob): """ Randomly blur an image. Args - img: (Pillow.Image) - prob: Probability to blur """ if np.random.random() > prob: return img # TODO: stronger blur filters = [ ImageFilter.BoxBlur(3), ImageFilter.GaussianBlur(3), ImageFilter.Kernel((5, 5), (1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1)), ImageFilter.Kernel((5, 5), (0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0)), ImageFilter.Kernel((5, 5), (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)), ImageFilter.Kernel((5, 5), (0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0)), ] img = img.filter(np.random.choice(filters)) return img
def apply_edge_detector(input_image): # Apply median filter with 3x3 window median_image = input_image.filter(ImageFilter.MedianFilter(3)) # Apply 3x3 Sobel filters # Apply for X kernel_x = (-1, 0, 1, -2, 0, 2, -1, 0, 1) kernelx_image = median_image.filter( ImageFilter.Kernel((3, 3), kernel_x, scale=1)) # Apply for Y kernel_y = (1, 2, 1, 0, 0, 0, -1, -2, -1) kernely_image = median_image.filter( ImageFilter.Kernel((3, 3), kernel_y, scale=1)) # Sum the pixels of the X and Y sobel images merged = ImageChops.add(kernelx_image, kernely_image) # Thresholding merged = merged.point(lambda x: 0 if x < 60 else 255) return merged
def apply_edge_detector(input_image): # Apply median filter with 3x3 window median_image = input_image.filter(ImageFilter.MedianFilter(3)) # Apply 3x3 center difference filters # Apply for X kernel_x = (0, 0, 0, 1, 0, -1, 0, 0, 0) kernelx_image = median_image.filter( ImageFilter.Kernel((3, 3), kernel_x, scale=2)) # Apply for Y kernel_y = (0, 1, 0, 0, 0, 0, 0, -1, 0) kernely_image = median_image.filter( ImageFilter.Kernel((3, 3), kernel_y, scale=2)) # Sum the pixels of X and Y merged = ImageChops.add(kernelx_image, kernely_image) # Thresholding merged = merged.point(lambda x: 0 if x < 10 else 255) return merged
def img_kernel(filename, size, kernel, scale=None, offset=None): im = get_img(filename) if scale is not None and scale.strip() != '': scale = float(scale) else: scale = None if offset is not None and offset.strip() != '': offset = float(offset) else: offset = 0 im_filter = ImageFilter.Kernel(size, kernel, scale, offset) res = im.filter(im_filter) return save_img(res, filename)
def sharpness(img): """Calculate the sharpness of the image using a Laplacian Kernel. """ img_bw = img.convert('L') filtered = img_bw.filter( ImageFilter.Kernel( (3, 3), # Laplacian Kernel: (-1, -1, -1, -1, 8, -1, -1, -1, -1), 1, 0, )) return np.std(filtered)
def filter_convolutional(image, kernel, size=(3,3), title=str()\ , xlabel=str(), ylabel=str(), is_show=False, extension='conv'): '''Apply convolutional filter over a PIL image using a kernel given as parameter of this function. Image is converted into gray levels. Transformed image histogram may also be displayed. ''' #--------------------------------------------------------------------------- # Les filtres par convolution ne supportent que les formats RGB et L # d'encodage des pixels. L'image est réencodée en L #--------------------------------------------------------------------------- image_L = Image.fromarray(np.array(image)).convert('L') #--------------------------------------------------------------------------- # Construction du filtre avec le notau pré-définie #--------------------------------------------------------------------------- image_filtered = ImageFilter.Kernel(size, kernel.flatten(), scale=None, offset=0) #--------------------------------------------------------------------------- # Filtrage appliqué a l'image #--------------------------------------------------------------------------- image_filtered = image_L.filter(image_filtered) #--------------------------------------------------------------------------- # L'histograme des pixels et des pixels cumulés est affiché #--------------------------------------------------------------------------- image_hist(image_filtered, title=title, xlabel=xlabel, ylabel=ylabel) image_hist(image_filtered\ , title=title+' cumulé'\ , xlabel=xlabel\ , ylabel=ylabel+" cumulés"\ ,cumulative=True) #--------------------------------------------------------------------------- # Sauvegarde de l'image filtree dans un fichier #--------------------------------------------------------------------------- filename = "./data/image_filtered_conv_" + extension + ".png" image_filtered.save(filename) #--------------------------------------------------------------------------- # L'histograme des pixels et des pixels cumulés est affiché #--------------------------------------------------------------------------- if is_show is True: image_filtered.show() return filename, image_filtered
def custom(self, **kwargs): params = kwargs['params'] kernel = tuple(map(int, params['kernel'].split(' '))) if 'scale' in params.keys(): scale = int(params['scale']) else: scale = 1 if 'offset' in params.keys(): offset = int(params['offset']) else: offset = 0 n = int(len(kernel)**0.5) f = ImageFilter.Kernel((n, n), kernel, scale, offset) self.final = self.img.filter(f) self.filter = "custom"
def filter(image_matrix, effect): image_object = Image.fromarray(image_matrix) # define sharpen and blur kernels sharpen_kernel = np.asarray([0, -1 / 3, 0, -1 / 3, 3, -1 / 3, 0, -1 / 3, 0]) blur_kernel = np.asarray([1 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 9]) unsharp_mask_kernel = (-1 / 256) * np.asarray([1, 4, 6, 4, 1, 4, 16, 24, 16, 4, 6, 24, -476, 24, 6, 4, 16, 24, 16, 4, 1, 4, 6, 4, 1]) # convolve with kernels if effect == 'sharpen': img_sharpen = image_object.filter(ImageFilter.Kernel((3, 3), sharpen_kernel, scale=None)) final_img = img_sharpen elif effect == 'blur': img_blur = image_object.filter(ImageFilter.Kernel((3, 3), blur_kernel, scale=None)) final_img = img_blur elif effect == 'unsharp': img_unsharp = image_object.filter(ImageFilter.Kernel((5, 5), unsharp_mask_kernel, scale=None)) final_img = img_unsharp # return an image object of the filtered image, which can be feedback into the input again return np.asarray(final_img)
def remove_specks_or_blur(X): """This attempts to reduce the noise introduced in the later pages that are harder to read. It does this by attempting to make any black pixel white that does not have enough black neighbour pixels. Alternatively, it applies blurring to the image. Params: X - feature vectors stored as rows in a matrix """ speck_removal_convolution = ( 1, 1, 1, 1, 1, 1, 1, 1, 1 ) convolution = ImageFilter.Kernel( size=(3,3), kernel=speck_removal_convolution, scale=9, offset=0 ) # Apply to each letter individually for i in range(len(X)): # Reshape the feature vector to image dimensions and convert the object # to a Pil Image rectangular_image_array = np.reshape(X[i,:], NEW_DIMENSIONS_2D) image = Image.fromarray(rectangular_image_array) image = image.convert("L") if APPLY_BLURRING: image = image.filter(GaussianBlur(radius=2)) #image = image.filter(ImageFilter.BLUR) elif APPLY_SPECK_REMOVAL: image = image.filter(convolution) # Convert the Pil Image back to a numpy feature vector image_array = np.array(image) image_array = np.reshape(image_array, (NEW_DIMENSIONS,)) X[i,:] = image_array return X
def sobel_filt_V(): if request.method == "POST": try: delete_images() image_src = 'static/uploads/img.png' im = Image.open(image_src).convert(mode="L") sobel_mask = ( 1, 0, -1, 2, 0, -2, 1, 0, -1, ) im_sobel = im.filter(ImageFilter.Kernel((3,3),sobel_mask,scale=4)) im_sobel.save('static/uploads/img_sobel_V.png') image_url_sobel = url_for('static',filename="uploads/img_sobel_V.png") return jsonify({'image_url_sobel_V' : image_url_sobel}) except Exception as e: print(e)