def disprange_filter(): if request.method == "POST": try: delete_images() image_src = 'static/uploads/img.png' im = Image.open(image_src) # Se calculeaza "distanta" dintre pixelelii mai mari ca pixelul median si pixelii mai mici ca pixelul median dintr-un bloc de pixeli 3x3 im_disprange = Image.fromarray( np.uint8( 1 / 4 * np.array(im.filter(ImageFilter.RankFilter(size=3, rank=5)), dtype='float32') + 1 / 4 * np.array(im.filter(ImageFilter.RankFilter(size=3, rank=6)), dtype='float32') + 1 / 4 * np.array(im.filter(ImageFilter.RankFilter(size=3, rank=7)), dtype='float32') + 1 / 4 * np.array(im.filter(ImageFilter.RankFilter(size=3, rank=8)), dtype='float32') - 1 / 4 * np.array(im.filter(ImageFilter.RankFilter(size=3, rank=0)), dtype='float32') - 1 / 4 * np.array(im.filter(ImageFilter.RankFilter(size=3, rank=1)), dtype='float32') - 1 / 4 * np.array(im.filter(ImageFilter.RankFilter(size=3, rank=2)), dtype='float32') - 1 / 4 * np.array(im.filter(ImageFilter.RankFilter(size=3, rank=3)), dtype='float32'))) im_disprange.save('static/uploads/img_disprange.png') image_url_disprange = url_for('static', filename="uploads/img_disprange.png") return jsonify({'image_url_disprange': image_url_disprange}) except Exception as e: print(e)
def __random_rank_blur(img): w, h = img.size[0], img.size[1] img = img.resize((2 * w, 2 * h)) rank = np.random.randint(0, rank_blur_range * rank_blur_range) img = img.filter(ImageFilter.RankFilter(rank_blur_range, rank)) img = img.resize((w, h)) return img
def auto_rankfilter_exec(self): self.image = self.image.filter( ImageFilter.RankFilter( self.ops_vals["rankfilter"], int(self.ops_vals["rankfilter"] * self.ops_vals["rankfilter"] / 2))) self.loadImageFromPIX(self.image)
def call(self, img): if img is None: raise ValueError('img is None') im_n = img.copy() gauss_blur_low, gauss_blur_high = 0, self.gauss_blur blur_low, blur_high = gauss_blur_high, gauss_blur_high + self.blur smooth_low, smooth_high = blur_high, blur_high + self.smooth smooth_more_low, smooth_more_high = smooth_high, smooth_high + self.smooth_more rank_low, rank_high = smooth_more_high, smooth_more_high + self.rank_filter r = random() if gauss_blur_low <= r <= gauss_blur_high: im_n = im_n.filter(ImageFilter.GaussianBlur(1)) elif blur_low < r <= blur_high: im_n = im_n.filter(ImageFilter.BLUR) elif smooth_low < r <= smooth_high: im_n = im_n.filter(ImageFilter.SMOOTH) elif smooth_more_low < r <= smooth_more_high: im_n = im_n.filter(ImageFilter.SMOOTH_MORE) elif rank_low < r <= rank_high: im_n = im_n.filter(ImageFilter.RankFilter(size=3, rank=7)) else: pass return im_n
def features(self): """ Calculate significant image features. This is done by: 1. Finding the `channels` most prominent colors after filtering out values less than `min_color` or greater than `max_color`. 2. Removing all other colors and converting the image to monochrome. 3. Applying a rank filter to reduce noise. 3. Separating the image into at most `max_chars` features, i.e. areas with at least `min_feature_pixels` number of contiguous pixels. Return: list: A least of monochrome `Image` objects representing significant features. """ im = monochrome(self.im, limit=self.channels, min=self.min_color, max=self.max_color) if self.rank_size > 0: im = im.filter( ImageFilter.RankFilter(self.rank_size, self.rank_value)) return features(im, max_features=self.max_chars, min_pixels=self.min_feature_pixels)
def random_rank_blur(img, rank_blur_range): img = Image.fromarray(img) w, h = img.size[0], img.size[1] img = img.resize((2 * w, 2 * h)) rank = np.random.randint(0, rank_blur_range * rank_blur_range) img = img.filter(ImageFilter.RankFilter(rank_blur_range, rank)) img = img.resize((w, h)) img = np.array(img) return img
def filter(request, id_image): myObj = Photo.objects.get(pk=id_image) image_path = myObj.file.path img = Image.open(image_path) # applying the rank filter out = img.filter(ImageFilter.RankFilter(size=3, rank=3 * 3 - 1)) out.save(image_path) return redirect('effects', id_image)
def rnk(image, radius, rank=50, amount=100): """Apply a filter - amount: 0-1""" rank /= 100.0 r = int((radius * radius - 1) * rank) image = imtools.convert_safe_mode(image) ranked = image.filter(ImageFilter.RankFilter(radius, r)) if amount < 100: return imtools.blend(image, ranked, amount / 100) return ranked
def rank_filter(self,rank): ''' 用于rankfilter操作 Args: rank:像素的次序 ''' self.resume() self.img = self.img.filter(ImageFilter.RankFilter(3,rank)) self.update_image()
def char_op(trg): trg = rem_back(trg) trg = rem_back_rev(trg) cnt = ImageEnhance.Contrast(trg) trg = cnt.enhance(2) trg = trg.filter(ImageFilter.MedianFilter(9)) trg = trg.filter(ImageFilter.RankFilter(5, 3)) br = ImageEnhance.Brightness(trg) trg = br.enhance(1) trg = trg.convert("RGB") trg = ImageOps.expand(trg, 30, 'white') return trg
def generate_map(size, kernelsize, numiterations): im = Image.new('RGB', (size, size), color=IMPASSABLE) # init with random data for x in range(0, im.width): for y in range(0, im.height): im.putpixel((x, y), random.choice([IMPASSABLE, PASSABLE])) # apply filter multiple times for i in range(numiterations): im = im.filter(ImageFilter.RankFilter(kernelsize, kernelsize**2 // 2)) return im
def augment(image): random_transform = random.randint(-1, 4) if random_transform == 0: image = image.rotate(random.randint(-5, 5)) if random_transform == 1: image = image.filter(ImageFilter.GaussianBlur(radius=1)) if random_transform == 2: image = image.filter(ImageFilter.RankFilter(size=3, rank=1)) if random_transform == 3: image = image.filter(ImageFilter.MedianFilter(size=3)) if random_transform == 4: image = image.filter(ImageFilter.MaxFilter(size=3)) return image
def getcode(image): threshold = 69 table = [] for i in range(256): if i < threshold: table.append(0) else: table.append(1) image = Image.open(image).convert('L') image = image.resize((216, 81)) image = image.filter(ImageFilter.RankFilter(5, 13)) image = image.point(table, '1') image.show() code = pytesseract.image_to_string(image, config='--psm letters') return code
def modifyfunction(): # temp = Image.open("display.jpg") playList = [ ImageFilter.CONTOUR, ImageFilter.EMBOSS, ImageFilter.EDGE_ENHANCE_MORE, ImageFilter.BLUR, ImageFilter.DETAIL, ImageFilter.FIND_EDGES, ImageFilter.EDGE_ENHANCE, ImageFilter.SMOOTH_MORE, ImageFilter.SMOOTH, ImageFilter.SHARPEN, ImageFilter.RankFilter(5, 0), ImageFilter.MaxFilter(3), ImageFilter.MinFilter(3) ] for i in playList: temp = Image.open("display.jpg") new_img = temp.filter(i) new_img.show()
def predict(self, img): # img = np.array(img.convert('L')) img = img.convert('L') # Gray scale ne_img = ImageEnhance.Contrast(img).enhance(2) ers_img = ne_img.filter(ImageFilter.RankFilter(3, 1)) res_img = ers_img.resize((res_width, res_height * 3), Image.ANTIALIAS) img = res_img # We divide the test image in 3 # We could also try to test with the testing set of 1 character images width, height = img.size area = (0, height / 3, width, height - height / 3) img2 = (img.crop(area)) area = (0, (height / 3) * 2, width, height) img3 = (img.crop(area)) area = (0, 0, width, height / 3) img = (img.crop(area)) img = np.array(img) img2 = np.array(img2) img3 = np.array(img3) feat = np.resize(img, tam_feature_vec) # feature vector feat2 = np.resize(img2, tam_feature_vec) # feature vector feat3 = np.resize(img3, tam_feature_vec) # feature vector # d1 = np.linalg.norm(self.model - feat, axis=1) # measure distance --- Frobenius Norm / Euclidean norm dist = (np.sqrt(np.cumsum(np.square(self.model - feat), axis=1)))[:, -1] # d2 = np.linalg.norm(self.model - feat2, axis=1) # measure distance --- Frobenius Norm / Euclidean norm dist2 = (np.sqrt(np.cumsum(np.square(self.model - feat2), axis=1)))[:, -1] # d3 = np.linalg.norm(self.model - feat3, axis=1) # measure distance --- Frobenius Norm / Euclidean norm dist3 = (np.sqrt(np.cumsum(np.square(self.model - feat3), axis=1)))[:, -1] y_pred = self.y_train[np.argmin(dist)] # Get the closest y_pred2 = self.y_train[np.argmin(dist2)] # Get the closest y_pred3 = self.y_train[np.argmin(dist3)] # Get the closest final_pred = [y_pred, y_pred2, y_pred3] return final_pred
def predict(self, img): # img = np.array(img.convert('L')) img = img.convert('L') # Gray scale ne_img = ImageEnhance.Contrast(img).enhance(2) ers_img = ne_img.filter(ImageFilter.RankFilter(3, 1)) img = np.array(ers_img) feat = np.resize(img, tam_feature_vec) # feature vector dist = np.linalg.norm( self.model - feat, axis=1) # measure distance --- Frobenius Norm / Euclidean norm # dist = (np.sum(np.abs(self.model - feat) ** 2, axis=-1) ** (1. / 2)) SLOWER y_pred = self.y_train[np.argmin(dist)] # Get the closest return y_pred
def loadData(filePath): f = open(filePath, 'rb') data = [] img = image.open(f) img = img.filter(ImageFilter.RankFilter(3, 8)) m, n = img.size print(m, n) for i in range(m): for j in range(n): # RGB 0-1 x, y, z = img.getpixel((i, j)) # color in data data.append([x / 256.0, y / 256.0, z / 256.0]) f.close() return log_pic(np.mat(data), 10), m, n
def rank_filter(self): image = Image.open(self.name) # print("Params: ", self.container.rwindow.mask) try: subwindow = RgbImageWindow( self.name, 0, self.container, image.filter( ImageFilter.RankFilter( size=self.container.rwindow.filter_size, rank=self.container.rwindow.filter_rank))) subwindow.update_pixmap(subwindow.image) if not subwindow: QMessageBox.information(self.container, "Error", "Fail to create a sub window") else: self.container.mdiArea.addSubWindow(subwindow) subwindow.show() except Exception: QMessageBox.information(self.container, "Error", "Parameter error")
def outlineMarks(image, imageWidth, imageHeight): def colorsAreVeryDifferent(color1, color2): r1, g1, b1 = color1[0], color1[1], color1[2] r2, g2, b2 = color2[0], color2[1], color2[2] if (r1 - r2 > 15 or g1 - g2 > 15 or b1 - b2 > 15): return True return False image = image.resize((imageWidth, imageHeight), Image.BICUBIC) maxPass = image.filter(ImageFilter.RankFilter(13, 99)) #radius 13 for x in range(image.size[0]): for y in range(image.size[1]): currentColor = image.getpixel((x, y)) maxPassColor = maxPass.getpixel((x, y)) #Compare current pixel with locally brightest thing if (colorsAreVeryDifferent(maxPassColor, currentColor)): image.putpixel((x, y), (0, 255, 0)) #make pixel very green else: image.putpixel((x, y), (255, 255, 255)) return image
def __init__(self, archivo): self.archivo = archivo self.img = Image.open(archivo) size = self.img.size # print(self.img.size) tam = 1600 self.img = self.img.resize( (tam, int(size[1] * tam / size[0]))) if size[0] > size[1] else self.img.resize( (int(size[0] * tam / size[1]), tam)) # self.img = self.img.filter(ImageFilter.UnsharpMask(6,80)) # self.img = self.img.filter(ImageFilter.GaussianBlur()) # self.img = self.img.filter(ImageFilter.UnsharpMask(4)) tamfilter = 3 self.img = self.img.filter( ImageFilter.RankFilter(tamfilter, int(tamfilter * tamfilter / 2))) # self.img = ImageOps.equalize(self.img) # self.img = ImageOps.autocontrast(self.img) # print(self.img.size) self.regiones = []
def alphaqsr_filter(): if request.method == "POST": try: delete_images() image_src = 'static/uploads/img.png' im = Image.open(image_src) alpha = int(request.get_data()) imgname = 'img_alphaqsr_' + str(alpha) + '.png' if alpha == 1: # Se calculeaza "distanta" 2 pixeli din capatul vectorului minus alpha dintr-un bloc de pixeli 3x3 im_alphaqsr = Image.fromarray( np.uint8( np.array( im.filter(ImageFilter.RankFilter(size=3, rank=7))) - np.array( im.filter(ImageFilter.RankFilter(size=3, rank=1)))) ) im_alphaqsr.save('static/uploads/' + imgname) image_url_alphaqsr = url_for('static', filename="uploads/" + imgname) return jsonify({'image_url_alphaqsr': image_url_alphaqsr}) elif alpha == 2: im_alphaqsr = Image.fromarray( np.uint8( np.array( im.filter(ImageFilter.RankFilter(size=3, rank=6))) - np.array( im.filter(ImageFilter.RankFilter(size=3, rank=2)))) ) im_alphaqsr.save('static/uploads/' + imgname) image_url_alphaqsr = url_for('static', filename="uploads/" + imgname) return jsonify({'image_url_alphaqsr': image_url_alphaqsr}) elif alpha == 3: im_alphaqsr = Image.fromarray( np.uint8( np.array( im.filter(ImageFilter.RankFilter(size=3, rank=5))) - np.array( im.filter(ImageFilter.RankFilter(size=3, rank=3)))) ) im_alphaqsr.save('static/uploads/' + imgname) image_url_alphaqsr = url_for('static', filename="uploads/" + imgname) return jsonify({'image_url_alphaqsr': image_url_alphaqsr}) except Exception as e: print(e)
def build_model(self, traindata): # Initialization num_train = len(traindata) print(num_train) model = np.zeros((num_train, tam_feature_vec)) y_train = [['U+0000'] * 3 for i in range(num_train)] # Convert images to features for i in range(num_train): img, codes = traindata[i] # Get an image and label # img = np.array(img.convert('L')) # Gray scale img = img.convert('L') # Gray scale ne_img = ImageEnhance.Contrast(img).enhance(2) ers_img = ne_img.filter(ImageFilter.RankFilter(3, 1)) img = np.array(ers_img) # opencvImage = cv2.cvtColor(np.array(img),cv2.IMREAD_GRAYSCALE) # pxmin = np.min(opencvImage) # pxmax = np.max(opencvImage) # imgContrast = ((opencvImage - pxmin) / (pxmax - pxmin)) * 500 # kernel = np.ones((3, 3), np.uint8) # imgMorph = cv2.erode(imgContrast, kernel, iterations=2) # # imgMorph = np.array(imgMorph, dtype=float)/float(255) # imgMorph = imgMorph.astype(np.uint) # cv2.imwrite('out2.png', imgMorph) # cv2.imshow('image', imgMorph) # cv2.waitKey(0) # cv2.destroyAllWindows() # model[i,:] = np.resize(img,512) # feature vector model[i, :] = np.resize(img, tam_feature_vec) y_train[i] = codes # Keep model and labels self.model = model self.y_train = y_train
def main(): image = Image.open('../lenna.png') # Create a grayscale 3x3 sample image with values (0-9) * 28 sample_image = Image.new('L', (3, 3)) sample_image.putdata(list(map(lambda x: x * 28, range(9)))) sample_image.resize((600, 600)).show('Sample image before ranking') # Apply 3x3 rank filters with ranks ranging 0-9 for i in range(9): time.sleep(0.5) rank_filter = ImageFilter.RankFilter(3, rank=i) ranked_image = sample_image.filter(rank_filter) ranked_image.resize((600, 600)).show('Rank: %s, size 3x3' % i) # Now apply rank-based filters to the original image image.show('Original') for size in range(3, 9, 2): time.sleep(0.5) # Median filter, rank = (size * size) / 2 (the median value of # the sorted window). The median filter is used largely for # noise reduction. median_filter = ImageFilter.MedianFilter(size) median_filter_image = image.filter(median_filter) median_filter_image.show('Median filter, size: %sx%s' % (size, size)) # Min filter, rank = 0 or the smallest pixel value in the sorted # window. Used in astrophotography. Dilates dark objects. min_filter = ImageFilter.MinFilter(size) min_filter_image = image.filter(min_filter) min_filter_image.show('Minimum filter, size: %sx%s' % (size, size)) # Max filter, rank = size * size - 1 or the biggest pixel value # in the sorted window. max_filter = ImageFilter.MaxFilter(size) max_filter_image = image.filter(max_filter) max_filter_image.show('Maximum filter, size: %sx%s' % (size, size))
"SHARPEN", "RankFilter", "MaxFilter", "MinFilter", ] playList_dict = {"CONTOUR": ImageFilter.CONTOUR, "EMBOSS": ImageFilter.EMBOSS, "EDGE_ENHANCE_MORE": ImageFilter.EDGE_ENHANCE_MORE, "BLUR": ImageFilter.BLUR, "DETAIL": ImageFilter.DETAIL, "FIND_EDGES":ImageFilter.FIND_EDGES, "EDGE_ENHANCE": ImageFilter.EDGE_ENHANCE, "SMOOTH_MORE": ImageFilter.SMOOTH_MORE, "SMOOTH": ImageFilter.SMOOTH, "SHARPEN": ImageFilter.SHARPEN, "RankFilter": ImageFilter.RankFilter(5,0), "MaxFilter": ImageFilter.MaxFilter(3), "MinFilter": ImageFilter.MinFilter(3), } def CurSelet(self): key = str((listbox.get(ACTIVE))) print(key) print(playList_dict[key]) temp = Image.open("pic/display.jpg") new_img = temp.filter(playList_dict[key]) new_img.save("new_img.jpg") outputFile = new_img.resize((1000,600),Image.ANTIALIAS) outputFile.save("pic/{}.jpg".format(key)) listbox = tk.Listbox(gui, background="Blue", fg="white",selectbackground="Red",highlightcolor="Red")
def medfilt(pic=None, letter=None, level=7): pic = getpic(pic, letter) pic1 = pic.filter(ImageFilter.RankFilter(3, level)) # pic1.show(title = "Rank filter applied") return pic1
def build_model(self, traindata): # Initialization num_train = len(traindata) print(num_train) model = np.zeros((num_train * 3, tam_feature_vec)) # We can use this part to divide the three letter images and then feed them the same way as the one letter training set # we create the pickle set using this part of the code # Uncomment the parts of the code that you need # TAGS = ['U+3042', 'U+3044', 'U+3046', 'U+3048', 'U+304A', 'U+304B', 'U+304D', 'U+304F', 'U+3051', 'U+3053', # 'U+3055', 'U+3057', 'U+3059', 'U+305B', 'U+305D', 'U+305F', 'U+3061', 'U+3064', 'U+3066', 'U+3068', # 'U+306A', 'U+306B', 'U+306C', 'U+306D', 'U+306E', 'U+306F', 'U+3072', 'U+3075', 'U+3078', 'U+307B', # 'U+307E', 'U+307F', 'U+3080', 'U+3081', 'U+3082', 'U+3084', 'U+3086', 'U+3088', 'U+3089', 'U+308A', # 'U+308B', 'U+308C', 'U+308D', 'U+308F', 'U+3090', 'U+3091', 'U+3092', 'U+3093'] # training_data = [] y_train = [['U+0000'] for i in range(num_train * 3)] # Convert images to features for i in range(num_train): img, codes = traindata[i] # Get an image and label # img = np.array(img.convert('L')) # Gray scale img = img.convert('L') # Gray scale ne_img = ImageEnhance.Contrast(img).enhance(2) ers_img = ne_img.filter(ImageFilter.RankFilter(3, 1)) res_img = ers_img.resize((res_width, res_height * 3), Image.ANTIALIAS) img = res_img width, height = img.size area = (0, height / 3, width, height - height / 3) img2 = (img.crop(area)) area = (0, (height / 3) * 2, width, height) img3 = (img.crop(area)) area = (0, 0, width, height / 3) img = (img.crop(area)) # img.show() # img2.show() # img3.show() img = np.array(img) img2 = np.array(img2) img3 = np.array(img3) ########### If you need to create pickle # training_data.append([img,codes[0]]) # training_data.append([img2, codes[1]]) # training_data.append([img3, codes[2]]) ########### # opencvImage = cv2.cvtColor(np.array(img),cv2.IMREAD_GRAYSCALE) # pxmin = np.min(opencvImage) # pxmax = np.max(opencvImage) # imgContrast = ((opencvImage - pxmin) / (pxmax - pxmin)) * 500 # # kernel = np.ones((3, 3), np.uint8) # imgMorph = cv2.erode(imgContrast, kernel, iterations=2) # # imgMorph = np.array(imgMorph, dtype=float)/float(255) # imgMorph = imgMorph.astype(np.uint) # cv2.imwrite('out2.png', imgMorph) # cv2.imshow('image', imgMorph) # cv2.waitKey(0) # cv2.destroyAllWindows() # model[i,:] = np.resize(img,512) # feature vector model[i, :] = np.resize(img, tam_feature_vec) model[i + num_train, :] = np.resize(img2, tam_feature_vec) model[i + num_train * 2, :] = np.resize(img3, tam_feature_vec) #print(np.array(img).shape) #print(len(model[i,:])) #print(len(np.resize(img,512))) # print(codes) # print("meee"+codes[2]) y_train[i] = codes[0] y_train[i + num_train] = codes[1] y_train[i + num_train * 2] = codes[2] if i % 1000 == 0: print("Training ", i) # break ######################################################################## #In case you need to build the pickle data set # Shuffle the data just in case the words are ordered alphabetically # random.shuffle(training_data) # # X = [] # y = [] # # for features, label in training_data: # X.append(features) # y.append(label) # # X = np.array(X).reshape(-1, res_width, res_height, 1) # # pickle_out = open("X_THREE_2.pickle", "wb") # pickle.dump(X, pickle_out) # pickle_out.close() # # pickle_out = open("y_THREE_2.pickle", "wb") # pickle.dump(y, pickle_out) # pickle_out.close() ########################################################################## # Keep model and labels self.model = model self.y_train = y_train
targets = AlconTargets(datapath, train_ratio=0.8) testdata = AlconDataset(datapath,targets.test, isTrainVal=False) N = len(testdata) sheet = testdata.getSheet() # Get initial sheet res_width = 40 res_height = 50 model = tf.keras.models.load_model("3.0T-128-2-128-1.model") for i in range(N): # Prediction img = testdata[i] # Get data # img.show() img = img.convert('L') # Gray scale ne_img = ImageEnhance.Contrast(img).enhance(2) ers_img = ne_img.filter(ImageFilter.RankFilter(3, 1)) res_img = ers_img.resize((res_width, res_height * 3), Image.ANTIALIAS) img = res_img # img.show() width, height = img.size area = (0, height / 3, width, height - height / 3) img2 = (img.crop(area)) area = (0, (height / 3) * 2, width, height) img3 = (img.crop(area)) area = (0, 0, width, height / 3) img = (img.crop(area)) img = (np.array(img)).reshape(-1, res_width, res_height, 1) img2 = (np.array(img2)).reshape(-1, res_width, res_height, 1) img3 = (np.array(img3)).reshape(-1, res_width, res_height, 1)
def process_image_rankfilter(img_name): img = Image.open(pathlib.Path(img_name)) img = img.filter(ImageFilter.RankFilter(size=9, rank=2)) img.save(export_folder + "/RankFilter_" + format(Path(img_name).stem) + image_extension) print("RankFilter added successfully")
for i in f1: #print(os.path.join(r1)) counter += 1 label = TAGS.index(adding) # if counter==3256: n = os.path.join(r1, i) #img_array = cv2.imread(n, cv2.IMREAD_GRAYSCALE) # img_array = img_array # imgContrast = cv2.pow(img_array/255.0, 1.1) # img_array = imgContrast # img = Image.open(n) img = img.convert('L') # Gray scale n_img = ImageEnhance.Contrast(img).enhance(1.5) img = n_img.filter(ImageFilter.RankFilter(3, 2)) img = img.resize((NEW_WIDTH, NEW_HEIGTH), Image.ANTIALIAS) new_array = np.asanyarray(img) # kernel = np.ones((4, 4), np.uint8) #img_array = adjust_gamma(img_array, 0.5) # imgMorph = cv2.erode(imgContrast, kernel, iterations=1) # img_array = imgMorph #new_array = cv2.resize(img_array, (NEW_WIDTH, NEW_HEIGTH)) training_data.append([new_array, label]) # plt.imshow(img_array, cmap='gray') # graph it # plt.show() # plt.imshow(imgContrast, cmap='gray') # graph it # plt.show()
def test_rankfilter_properties(self): rankfilter = ImageFilter.RankFilter(1, 2) self.assertEqual(rankfilter.size, 1) self.assertEqual(rankfilter.rank, 2)