def remove_small_objects(input, output):
files = [f for f in listdir(input) if isfile(join(input, f))]
for file in files:
label = Image.open(f'{input}{file}')
blurred_label = label.filter(ImageFilter.ModeFilter(5))
blurred_label = blurred_label.filter(ImageFilter.ModeFilter(5))
blurred_label = blurred_label.filter(ImageFilter.ModeFilter(5))
blurred_label = blurred_label.filter(ImageFilter.ModeFilter(5))
blurred_label.save(f'{output}{file}')
def FinalProcess(img):
img = img.convert('L')
binarizing(img)
remove_hot_point(img)
img = img.filter(ImageFilter.MedianFilter(size=1))
img = img.filter(ImageFilter.ModeFilter(size=1))
img = img.filter(ImageFilter.MedianFilter(size=1))
W = segmentation_w(img)
H = segmentation_h(img)
pixeldata = img.load()
w, h = img.size
for i in range(w):
if (W[i] <= 2):
for j in range(h):
pixeldata[i, j] = 255
for i in range(h):
if (H[i] <= 2):
for j in range(w):
pixeldata[j, i] = 255
for i in range(w):
for j in range(h):
if (i - 5 < 0 or i + 5 >= w or j - 5 <= 0 or j + 5 >= h):
pixeldata[i, j] = 255
remove_hot_point(img)
binarizing(img)
return img
def vis():
img = Image.open('0.bmp').resize(
(80, 60), resample=Image.LANCZOS).rotate(40, resample=Image.BICUBIC)
arr = np.array(img)
img = Image.fromarray(arr.astype('uint8'))
kernel = np.ones((5, 5)) * -1
kernel[2, :] = 1
kernel[:, 2] = 1
kernel = kernel.reshape(5 * 5)
img = img.filter(ImageFilter.SMOOTH_MORE)
img = img.filter(ImageFilter.DETAIL)
img = img.filter(ImageFilter.EDGE_ENHANCE_MORE)
img = img.filter(ImageFilter.SMOOTH_MORE)
img = img.filter(ImageFilter.ModeFilter(3))
# img = img.filter(ImageFilter.Kernel((5,5), tuple(kernel)))
arr = np.array(img)
hist1 = list(arr.sum(axis=0))
hist2 = list(arr.sum(axis=1))
plt.plot(hist1)
plt.plot(hist2)
# plt.imshow(img)
plt.show()
img.save('res.png')
def updateTower(self):
# Download image and get data
downloaded_image = self.downloadTowerImage()
if downloaded_image is not None:
self.image = downloaded_image
else:
return
try:
# Gaussian blur image to smudge it
self.image = self.image.filter(ImageFilter.GaussianBlur(2))
# Exaggerate color
self.image = ImageEnhance.Color(self.image).enhance(10)
# Mode filter image to make it blocky
self.image = self.image.filter(ImageFilter.ModeFilter(5))
except:
pass
# Create PITowerModel and mark as changed
towerModel = PITowerModel(self.image)
# Avoid memory leak
del self.image
# Check if PITowerModel changed
if self.currentTowerModel:
if self.isTowerModelDifferent(towerModel):
# Avoid memory leak
del self.currentTowerModel
self.towerModelChanged(towerModel)
else:
self.currentTowerModel = towerModel
self.towerModelChanged(towerModel)
def show_value_1(window_size):
print('Window Size: ', window_size)
custom_filter = ImageFilter.ModeFilter(size=int(window_size))
img = im1.filter(custom_filter)
photo = ImageTk.PhotoImage(img)
l['image'] = photo
l.photo = photo
def FinalProcess(img):
img = img.convert('L')
binarizing(img)
remove_hot_point(img)
img = img.filter(ImageFilter.EDGE_ENHANCE)
img = img.filter(ImageFilter.ModeFilter(size=5))
img = img.filter(ImageFilter.MedianFilter(size=7))
return img
def common(image, radius, amount=100):
"""Apply a filter
- amount: 0-1"""
image = imtools.convert_safe_mode(image)
commoned = image.filter(ImageFilter.ModeFilter(radius))
if amount < 100:
return imtools.blend(image, commoned, amount / 100.0)
return commoned
def filter_image_mode(self):
global im
make_backup()
self.slider1.min = 1
self.slider1.max = 20
self.lbl1.text = "Strength: "
im = im.filter(ImageFilter.ModeFilter(int(self.slider1.value)))
self.save_temp_image()
def mix(self):
toImage = self.add()
img = self.read(r"%s\0.jpg" % self.path, self.width, self.height)
toImage_sm = toImage.filter(ImageFilter.ModeFilter(5)).filter(
ImageFilter.GaussianBlur)
final = self.blend(toImage_sm, img, 0.7)
final.rotate(-3)
final.save("mix.png")
def example6():
from PIL import Image
from fractions import Fraction
ship = Image.open("IPhone_Internals.jpg")
w, h = ship.size
slices = 12
#print(range(slices+1))
box = [Fraction(i, slices) for i in range(slices + 1)]
#print(box)
try:
for i in range(slices):
if i == slices:
break
for j in range(slices):
if j == slices:
break
bounds = int(w * box[i]), int(h * box[j]), int(
w * box[i + 1]), int(h * box[j + i])
#print(bounds)
except IndexError:
pass
logo = ship.crop(bounds)
#logo.show()
logo.save("IPhone_Internals_logo.jpg")
# ImageEnhance, ImageFilter, ImageOps
from PIL import ImageEnhance
e = ImageEnhance.Contrast(logo)
#e.enhance(2.0).show()
#e.enhance(4.0).show()
#e.enhance(8.0).show()
e.enhance(8.0).save("LHD_Number_1.jpg")
from PIL import ImageFilter
#logo.filter(ImageFilter.EDGE_ENHANCE).show()
e.enhance(8.0).filter(ImageFilter.EDGE_ENHANCE).save("LHD_Number_2.jpg")
# combine
p1 = e.enhance(8.0).filter(ImageFilter.ModeFilter(8))
#p1.filter(ImageFilter.EDGE_ENHANCE).show()
p1.filter(ImageFilter.EDGE_ENHANCE).save("LHD_Number_2_1.jpg")
# ImageOps
from PIL import ImageOps
ImageOps.autocontrast(logo).show()
logo.show()
ac = ImageEnhance.Contrast(ImageOps.autocontrast(logo))
ac.enhance(2.5).save("LHD_Number_3.jpg")
def mode_filter(y, width=5, n_app=5):
'''
Apply mode filter several times. Called by postprocess.
:param width: width of the filter. pixel units. same as height.
:param y: w x w nparray of binary values
:param n_app: number of filter applications
:return: median filtered nparray w x w
'''
yim = Image.fromarray(y).convert('L')
for i in range(n_app):
yim = yim.filter(ImageFilter.ModeFilter(size=width))
return np.array(yim)
def do_filters(self, image_bytes: bytes) -> discord.File:
with Image.open(BytesIO(image_bytes)) as im:
filter_chosen = random.choice(
(ImageFilter.GaussianBlur(radius=3), ImageFilter.UnsharpMask(),
ImageFilter.ModeFilter(size=5),
ImageFilter.MinFilter(size=3)))
with im.convert('RGBA').filter(filter_chosen) as im2:
buffer = BytesIO()
im2.save(buffer, 'png')
buffer.seek(0)
return discord.File(fp=buffer, filename="blob.png")
def __call__(self, img):
"""
Args:
img (PIL Image): Image to be blurred.
Returns:
PIL Image: Blurred image.
"""
if random.random() < self.p:
tmp = random.random();
if tmp < 0.33 :
return img.filter(ImageFilter.MaxFilter(size=3));
elif tmp < 0.66 :
return img.filter(ImageFilter.ModeFilter(size=5)); # mode size = 5
else :
return img.filter(ImageFilter.MinFilter(size=3));
return img
def filter_image(image_name, new_image_name, f_type):
image = Image.open(BASE_TRAIN_PATH + image_name)
filter_types = [
ImageFilter.GaussianBlur(3),
ImageFilter.MedianFilter(3),
ImageFilter.ModeFilter(3)
]
if 0 <= f_type < 3:
image.filter(filter_types[f_type])
else:
print('Incorrect value assigned')
image.save(BASE_FILTER_PATH + new_image_name)
print('Filter ', new_image_name + ' Original: ' + image_name)
def main(*arg):
# import image and convert to grayscale numpy array
img = np.asarray(Image.open("noise_impulsive.png").convert('L'),
dtype='float')
simg = Image.open("noise_impulsive.png")
dimg = simg.filter(ImageFilter.ModeFilter(size=5))
dimg.save("test.png")
img2 = np.asarray(Image.open("test.png").convert('L'), dtype='float')
out = unsharp_mask(img2, 2, 2)
final = Image.fromarray(out, mode='L')
final.show()
final.save("noiseImp_median_unsharp.png")
def main():
img = Image.new('RGB', (1081, 1081)) # About 16 pixels per km of map
draw = ImageDraw.Draw(img)
# Draw the levels of elevation
drawFirst(draw)
drawSecond(draw)
drawThird(draw)
img.save('generated_map.png') # Save the map
# Cut out sharp corners of the topology
postImg1 = Image.open('generated_map.png')
simg1 = postImg1.filter(ImageFilter.ModeFilter(size = 20))
simg1.save('generated_map_post.png')
# Smooth the topology
postImg2 = Image.open('generated_map_post.png')
simg2 = postImg2.filter(ImageFilter.BoxBlur(radius = 25))
simg2.save('generated_map_post.png')
def fetch_img(prc_i, num_t, img_q):
lines = np.loadtxt('imagenet/val.txt', str, delimiter='\n')
steps = int(floor(lines.size / num_t))
start = steps * prc_i
end = start + steps
flt = ImageFilter.ModeFilter(size=3)
if prc_i == num_t - 1:
end = lines.size
for i in range(start, end):
imname, label = lines[i].split(' ')
label = int(label) + 1
im = Image.open('imagenet/ILSVRC2012_img_val/' + imname).convert('RGB')
im = np.array(im.filter(flt))
processed_image = imresize(im, (width, height))
processed_image = (processed_image.astype(np.float32) / 256 - 0.5) * 2
processed_images = np.expand_dims(processed_image, axis=0)
img_q.put([processed_images, label])
def frosted_file(infile, outfile, blurSize=10, mode=5):
new_filename = outfile
if outfile == None:
bar_filename, ext = os.path.splitext(infile)
new_filename = f"{bar_filename}_frosted{ext}"
print(f"{infile} frosted(size = {blurSize}) -> {new_filename}")
with open(infile, 'rb') as imgfile:
img = Image.open(infile)
img = img.filter(ImageFilter.GaussianBlur(blurSize))
if mode > 0:
img = img.filter(ImageFilter.ModeFilter(mode))
img.show()
img.save(new_filename)
def work(file):
imgData, row, col = loadData(file)
km = KMeans(n_clusters=5)
label = km.fit_predict(imgData)
label = label.reshape([row, col])
pic_new = image.new("L", (row, col))
for i in range(row):
for j in range(col):
pic_new.putpixel((i, j), int(256 / (label[i][j] + 1)))
pic_new = pic_new.filter(ImageFilter.ModeFilter(7))
back = pic_new.getpixel((50, 170))
pic_new = pic_new.point(lambda x: 0 if x == back else 1)
pic_new = split_img(file, pic_new)
# return pic_new
pic_new.save("./Image_result1/7_2_result.jpg", "JPEG")
def photo_edit(request, id):
obj = Photo.objects.get(id=id)
if request.method == "POST":
form_filter = ImageFilterForm(request.POST)
if form_filter.is_valid():
image = Image.open(obj.photo)
path = "media/" + obj.photo.name
edited_photo = ""
if request.POST.get('select') == "blur":
edited_photo = image.filter(ImageFilter.GaussianBlur(radius=2))
elif request.POST.get('select') == "sharpen":
edited_photo = image.filter(ImageFilter.SHARPEN)
elif request.POST.get('select') == "edges":
edited_photo = image.filter(ImageFilter.FIND_EDGES)
elif request.POST.get('select') == "contour":
edited_photo = image.filter(ImageFilter.CONTOUR)
elif request.POST.get('select') == "modefilter":
edited_photo = image.filter(ImageFilter.ModeFilter(size=5))
edited_photo.save(path, format='jpeg')
return redirect("/edytuj/{}".format(obj.id))
return render(request, "photo_edit.html", {
"obj": obj,
"form_filter": form_filter
})
else:
form_filter = ImageFilterForm()
return render(request, "photo_edit.html", {
"obj": obj,
"form_filter": form_filter
})
def augment(input_dir, output, all_filters=False):
if os.path.exists(output):
shutil.rmtree(output)
print(input_dir, output)
for _, dirs, _ in os.walk(input_dir):
for dir in dirs:
for _, subdir, files in os.walk(input_dir + '/' + dir):
for file in files:
filename = input_dir + '/' + dir + '/' + file
output_file = output + '/' + dir
if not os.path.exists(output_file):
os.makedirs(output_file)
im = Image.open(filename)
im.save('%s/%s.jpg' %
(output_file, '.'.join(file.split('.')[:-1])))
gaussian_filter = ImageFilter.GaussianBlur(radius=5)
unsharp_filter = ImageFilter.UnsharpMask(radius=2,
percent=150,
threshold=3)
median_filter = ImageFilter.MedianFilter(size=3)
mode_filter = ImageFilter.ModeFilter(size=3)
filters = [gaussian_filter]
if all_filters:
filters = [
gaussian_filter, unsharp_filter, median_filter,
mode_filter
]
for i, filt in enumerate(filters):
for angle in [0, 10, 20, 30]:
#scale_rotate_translate(im.filter(filt), angle=angle).save(
# '%s/%s%s.%s.jpg' % (output_file, '.'.join(file.split('.')[:-1]), angle, i * 10))
scale_rotate_translate(
im.transpose(Image.FLIP_LEFT_RIGHT),
angle=angle).save(
'%s/%s%s%s.jpg' % (output_file, '.'.join(
file.split('.')[:-1]), angle, i))
from ipywidgets.embed import embed_minimal_html
from PIL import ImageFilter
import gmaps
gmaps.configure(api_key="AIzaSyCo99awBRG0JvRCoJC8M12-3EiAoLfElSM")
fig = gmaps.figure()
from PIL import Image
im = Image.open("/Users/Aakash/36.070403, 68.629560, 68.673354.png")
inputim = im.filter(ImageFilter.ModeFilter(8))
inputim.show()
pix = inputim.load()
imout = im.copy()
pixout = imout.load()
deltax = 68.673354 - 68.629560
locations = []
xlist = []
ylist = []
for i in range(0, inputim.size[0], 8): #x-axis search
for j in range(0, inputim.size[1], 8): #y-axis search
if pix[i, j][1] > 140:
pixout[i, j] = (255, 0, 0)
xlist = xlist + [-j / 1000 * delta + 36.070403]
ylist = ylist + [i / 1000 * delta + 68.629560]
for k in range(0, len(xlist), 5):
locations = locations + [(xlist[k], ylist[k])]
imout.show()
marker = gmaps.marker_layer(locations)
gradient_classed * 0.13
classed = np.nan_to_num(classed)
classed = np.round(classed)
classed = classed.astype(np.int)
max_ = classed.max()
classed[classed != max_] = 0
classed[classed == max_] = 1
classed = classed.astype(np.uint8)
im = Image.fromarray(255 * classed, mode='L')
imf = ImageFilter.ModeFilter(3)
im1 = im.filter(imf)
classed1 = np.asarray(im1)
#plt.imshow(classed1)
def array2raster(newRasterfn, geotrans, proj, array):
cols = array.shape[1]
rows = array.shape[0]
driver = gdal.GetDriverByName('GTiff')
outRaster = driver.Create(newRasterfn, cols, rows, 1, gdal.GDT_Byte)
outRaster.SetGeoTransform(geotrans)
outband = outRaster.GetRasterBand(1)
outband.WriteArray(array, 0, 0)
def bind_events(self):
"""
初始化菜单的组建，并绑定事件函数
:return:
"""
# File_Menu
if sys.platform == "darwin": # in macos
self.file_menu.add_command(
label='Open',
command=lambda: open_file(self.image_handler),
accelerator="Command+O")
self.bind_all("<Command-o>",
lambda e: open_file(self.image_handler))
self.file_menu.add_command(
label='Save',
command=lambda: save_file(self.image_handler),
accelerator="Command+S")
self.bind_all("<Command-s>",
lambda e: save_file(self.image_handler))
else: # windows or linux
self.file_menu.add_command(
label='Open',
command=lambda: open_file(self.image_handler),
accelerator="Ctrl+O")
self.bind_all("<Control-o>",
lambda e: open_file(self.image_handler))
self.file_menu.add_command(
label='Save',
command=lambda: save_file(self.image_handler),
accelerator="Ctrl+S")
self.bind_all("<Control-s>",
lambda e: save_file(self.image_handler))
self.bin_menu.add_command(
label='Simple Binarization',
command=lambda: create_scale(self.image_handler,
from_=0,
to=255,
command=self.image_handler.convert_B,
orient=tk.HORIZONTAL,
resolution=1))
self.bin_menu.add_command(
label='Random dithering',
command=lambda: create_scale(self.image_handler,
from_=0,
to=6,
command=self.image_handler.convert_B2,
orient=tk.HORIZONTAL,
resolution=0.1))
self.bin_menu.add_command(
label='Floyd-Steinberg dithering',
command=self.image_handler.convert_Floyd_dithering)
self.file_menu.add_command(label='Grayscale',
command=self.image_handler.convert_L)
self.file_menu.add_command(label='Equalize',
command=self.image_handler.equalize)
self.file_menu.add_command(label='Histogram',
command=self.image_handler.show_hist)
self.file_menu.add_command(label='Recover',
command=self.image_handler.recover)
if sys.platform == "darwin": # in macos
self.file_menu.add_command(label='Undo',
command=self.image_handler.undo,
accelerator="Command+Z")
self.bind_all("<Command-z>", self.image_handler.undo)
else: # windows or linux
self.file_menu.add_command(label='Undo',
command=self.image_handler.undo,
accelerator="Ctrl+Z")
self.bind_all("<Control-z>", self.image_handler.undo)
# Image enhance
self.enhance_menu.add_command(
label='Brightness',
command=lambda: create_scale(self.image_handler,
from_=0,
to=2,
command=self.image_handler.
brightness_enhance,
orient=tk.HORIZONTAL,
resolution=0.01))
self.enhance_menu.add_command(
label='Color',
command=lambda: create_scale(self.image_handler,
from_=0,
to=3,
command=self.image_handler.
color_enhance,
orient=tk.HORIZONTAL,
resolution=0.01))
self.enhance_menu.add_command(
label='Constrast',
command=lambda: create_scale(self.image_handler,
from_=0,
to=3,
command=self.image_handler.
contrast_enhance,
orient=tk.HORIZONTAL,
resolution=0.01))
self.enhance_menu.add_command(
label='Sharpness',
command=lambda: create_scale(self.image_handler,
from_=0,
to=3,
command=self.image_handler.
sharpness_enhance,
orient=tk.HORIZONTAL,
resolution=0.01))
# Blur and Filter
self.blur_filter_menu.add_command(label='BoxBlur',
command=lambda: self.image_handler.
apply_filter(ImageFilter.BoxBlur(3)))
self.blur_filter_menu.add_command(
label='GaussianBlur',
command=lambda: self.image_handler.apply_filter(
ImageFilter.GaussianBlur(3)))
self.blur_filter_menu.add_command(
label='MedianFilter',
command=lambda: self.image_handler.apply_filter(
ImageFilter.MedianFilter(3)))
self.blur_filter_menu.add_command(
label='MinFilter',
command=lambda: self.image_handler.apply_filter(
ImageFilter.MinFilter(3)))
self.blur_filter_menu.add_command(
label='ModeFilter',
command=lambda: self.image_handler.apply_filter(
ImageFilter.ModeFilter(3)))
self.blur_filter_menu.add_command(
label='UnsharpMask',
command=lambda: self.image_handler.apply_filter(ImageFilter.
UnsharpMask()))
self.blur_filter_menu.add_command(
label='MaxFilter',
command=lambda: self.image_handler.apply_filter(
ImageFilter.MaxFilter(3)))
self.blur_filter_menu.add_command(
label='RankFilter',
command=lambda: create_scale(self.image_handler,
from_=0,
to=8,
command=self.image_handler.
rank_filter,
orient=tk.HORIZONTAL,
resolution=1))
# other tool
self.other_menu.add_command(
label='Invert',
command=lambda: self.image_handler.apply_ops(ImageOps.invert))
self.other_menu.add_command(
label='Mirror',
command=lambda: self.image_handler.apply_ops(ImageOps.mirror))
self.other_menu.add_command(
label='Flip',
command=lambda: self.image_handler.apply_ops(ImageOps.flip))
self.other_menu.add_command(
label='Rotate',
command=lambda: create_scale(self.image_handler,
from_=0,
to=360,
command=self.image_handler.rotate,
orient=tk.HORIZONTAL,
resolution=1))
self.about_menu.add_command(
label='About',
command=lambda: tk.messagebox.showinfo('关于', '软件学院多媒体大作业\n版本：1.0'))
def loadShawn(default, imageFolder):
shawnPic = default.filter(ImageFilter.ModeFilter(size=15))
shawnPic.save(imageFolder + '/Shawn.' + session['ext'])
return 'success'
def process_image_modefilter(img_name):
img = Image.open(pathlib.Path(img_name))
img = img.filter(ImageFilter.ModeFilter(size=3))
img.save(export_folder + "/ModeFilter_" + format(Path(img_name).stem) +
image_extension)
print("ModeFilter added successfully")
def MedianFilter(img):
global args
return img.filter(
ImageFilter.ModeFilter(size=args.medianfilterintensifity))
def paint_texture(self, intensity):
self.image = self.image.filter(ImageFilter.ModeFilter(intensity))
def __cerateFilter(self):
'''模糊处理'''
self.__img = self.__img.filter(ImageFilter.BLUR)
filter = ImageFilter.ModeFilter(8)
self.__img = self.__img.filter(filter)
def filters(image, mode=FilterMode.Mean, p=1, **kwarg):
"""
la.image.FilterMode.Box:
Blurs the image by setting each pixel to the average value of the pixels
in a square box extending radius pixels in each direction.
Supports float radius of arbitrary size. Uses an optimized implementation
which runs in linear time relative to the size of the image for any radius value.
you should append param `radius`
radius: Size of the box in one direction. Radius 0 does not blur, returns an identical image.
Radius 1 takes 1 pixel in each direction, i.e. 9 pixels in total.
eg.
la.image.filters(image, mode=la.image.FilterMode.Box, radius=2)
la.image.FilterMode.Gaussian:
Gaussian blur filter.
you should append param `radius`
radius: Blur radius.
eg.
la.image.filters(image, mode=la.image.FilterMode.Gaussian, radius=2)
la.image.FilterMode.Unsharpmask:
Unsharp mask filter.
See Wikipedia’s entry on digital unsharp masking for an explanation of the parameters.
you should append param `radius`,`percent`,`threshold`
radius: Blur radius.
percent: Unsharp strength, in percent
threshold: Threshold controls the minimum brightness change that will be sharpened
eg.
la.image.filters(image, mode=la.image.FilterMode.Unsharpmask, radius=2, percent=150, threshold=3)
la.image.FilterMode.Rank:
Create a rank filter. The rank filter sorts all pixels in a window of the given size, and returns the rank’th value.
you should append param `size`,`rank`
size: The kernel size, in pixels.
rank: What pixel value to pick. Use 0 for a min filter,
size * size / 2 for a median filter, size * size - 1 for a max filter, etc.
eg.
la.image.filters(image, mode=la.image.FilterMode.Rank, size, rank)
la.image.FilterMode.Median:
Create a median filter. Picks the median pixel value in a window with the given size.
you should append param `size`
size: The kernel size, in pixels.
eg.
la.image.filters(image, mode=la.image.FilterMode.Median, size=3)
la.image.FilterMode.Min:
Create a min filter. Picks the lowest pixel value in a window with the given size.
you should append param `size`
size: The kernel size, in pixels.
eg.
la.image.filters(image, mode=la.image.FilterMode.Min, size=3)
la.image.FilterMode.Max:
Create a max filter. Picks the largest pixel value in a window with the given size.
you should append param `size`
size: The kernel size, in pixels.
eg.
la.image.filters(image, mode=la.image.FilterMode.Max, size=3)
la.image.FilterMode.Mode:
Create a mode filter. Picks the most frequent pixel value in a box with the given size.
Pixel values that occur only once or twice are ignored;
if no pixel value occurs more than twice, the original pixel value is preserved.
you should append param `size`
size: The kernel size, in pixels.
eg.
la.image.filters(image, mode=la.image.FilterMode.Mode, size=3)
la.image.FilterMode.Mean:
Normal blur.
eg.
la.image.filters(image, mode=la.image.FilterMode.Mean)
la.image.FilterMode.CONTOUR:
contour blur.
eg.
la.image.filters(image, mode=la.image.FilterMode.CONTOUR)
la.image.FilterMode.DETAIL:
detail blur.
eg.
la.image.filters(image, mode=la.image.FilterMode.DETAIL)
la.image.FilterMode.EDGE_ENHANCE:
Edge enhancement blur.
eg.
la.image.filters(image, mode=la.image.FilterMode.EDGE_ENHANCE)
la.image.FilterMode.EDGE_ENHANCE_MORE:
Edge enhancement more blur.
eg.
la.image.filters(image, mode=la.image.FilterMode.EDGE_ENHANCE_MORE)
la.image.FilterMode.EMBOSS:
emboss blur.
eg.
la.image.filters(image, mode=la.image.FilterMode.EMBOSS)
la.image.FilterMode.FIND_EDGES:
Find the edge blur.
eg.
la.image.filters(image, mode=la.image.FilterMode.FIND_EDGES)
la.image.FilterMode.SHARPEN:
Sharpen blur.
eg.
la.image.filters(image, mode=la.image.FilterMode.SHARPEN)
la.image.FilterMode.SMOOTH:
Smooth blur.
eg.
la.image.filters(image, mode=la.image.FilterMode.SMOOTH)
la.image.FilterMode.SMOOTH_MORE:
Smooth threshold blur.
eg.
la.image.filters(image, mode=la.image.FilterMode.SMOOTH_MORE)
Args:
image: a PIL instance.
mode:la.image.FilterMode.
p: probability that the image does this. Default value is 1.
Returns:
A PIL instance.
"""
if np.random.uniform()>p:
return image
if 'radius' not in kwarg:
kwarg['radius'] = 2
if 'size' not in kwarg:
kwarg['size'] = 3
if 'percent' not in kwarg:
kwarg['percent'] = 150
if 'threshold' not in kwarg:
kwarg['threshold'] = 3
if 'rank' not in kwarg:
kwarg['rank'] = 1
if mode=='box':
return image.filter(ImageFilter.BoxBlur(radius=kwarg['radius']))
elif mode=='gaussian':
return image.filter(ImageFilter.GaussianBlur(radius=kwarg['radius']))
elif mode=='unsharpmask':
return image.filter(ImageFilter.UnsharpMask(radius=kwarg['radius'], percent=kwarg['percent'], threshold=kwarg['threshold']))
elif mode=='rank':
return image.filter(ImageFilter.RankFilter(size=kwarg['size'], rank=kwarg['rank']))
elif mode=='median':
return image.filter(ImageFilter.MedianFilter(size=kwarg['size']))
elif mode=='min':
return image.filter(ImageFilter.MinFilter(size=kwarg['size']))
elif mode=='max':
return image.filter(ImageFilter.MaxFilter(size=kwarg['size']))
elif mode=='mode':
return image.filter(ImageFilter.ModeFilter(size=kwarg['size']))
elif mode=='BLUR':
return image.filter(ImageFilter.BLUR)
elif mode=='CONTOUR':
return image.filter(ImageFilter.CONTOUR)
elif mode=='DETAIL':
return image.filter(ImageFilter.DETAIL)
elif mode=='EDGE_ENHANCE':
return image.filter(ImageFilter.EDGE_ENHANCE)
elif mode=='EDGE_ENHANCE_MORE':
return image.filter(ImageFilter.EDGE_ENHANCE_MORE)
elif mode=='EMBOSS':
return image.filter(ImageFilter.EMBOSS)
elif mode=='FIND_EDGES':
return image.filter(ImageFilter.FIND_EDGES)
elif mode=='SHARPEN':
return image.filter(ImageFilter.SHARPEN)
elif mode=='SMOOTH':
return image.filter(ImageFilter.SMOOTH)
elif mode=='SMOOTH_MORE':
return image.filter(ImageFilter.SMOOTH_MORE)
else:
raise ValueError("mode must be la.image.FilterMode param")
