def cartoon(srcColor):
srcGray=cv2.cvtColor(srcColor,cv2.COLOR_BGR2GRAY)
print srcGray.shape,srcColor.shape
cv2.medianBlur(srcGray,5,srcGray)
mask=srcGray.copy().astype(np.uint8)
edges=srcGray.copy().astype(np.uint8)
### sketch detection
cv2.Laplacian(srcGray,cv2.CV_8U,edges,5)
cv2.threshold(edges,60,255,cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU,mask)
outImg=srcColor.copy()
tmp=outImg.copy()
### bilateral filtering ###
rep=10
for i in xrange(rep):
size=9;sigmaColor=9;sigmaSpace=7
cv2.bilateralFilter(outImg,size,sigmaColor,sigmaSpace,tmp)
cv2.bilateralFilter(tmp,size,sigmaColor,sigmaSpace,outImg)
output=cv2.bitwise_and(srcColor,srcColor,mask=mask)
cv2.edgePreservingFilter(output,output)
return output
def main():
# 動画の読み込み
# cap = cv2.VideoCapture('IMG_3984.mp4')
cap = cv2.VideoCapture('privacy.wmv')
# 動画終了まで繰り返し
while (cap.isOpened()):
# フレーム取得
ret, frame = cap.read()
if ret == True:
# フレームの速度計測
t = time.time()
frame = cv2.edgePreservingFilter(frame,
flags=1,
sigma_s=80,
sigma_r=0.4)
print('[INFO] elapsed time: {:.4f}'.format(time.time() - t))
# フレームを表示
cv2.imshow("edgePreserving", frame)
# qキーが押されたら途中終了
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
cv2.destroyAllWindows()
def cartoonizeStyle1(sig_r=0.4, sig_s=50):
global img_result
imgToCartoon = img.copy()
gray = cv2.cvtColor(imgToCartoon, cv2.COLOR_BGR2GRAY)
gray = cv2.GaussianBlur(gray, (3, 3), 0)
edged = cv2.Laplacian(gray, -1, ksize=5)
edged = 255 - edged
edgedPreserve = cv2.edgePreservingFilter(imgToCartoon,
flags=2,
sigma_s=sig_s,
sigma_r=sig_r)
img_result = cv2.bitwise_and(edgedPreserve, edgedPreserve, mask=edged)
img_result = cv2.GaussianBlur(img_result, (3, 3), 0)
img_result = cv2.medianBlur(img_result, 3)
#cv2.imshow("resultat2",result)
#cv2.imwrite("results/t33.jpg",result)
preview = img_result.copy()
preview = cv2.resize(
preview, (300, int((300 / img_result.shape[1]) * img_result.shape[0])),
0, 0, cv2.INTER_NEAREST)
preview = cv2.cvtColor(preview, cv2.COLOR_BGR2RGB)
preview = Image.fromarray(preview)
preview = ImageTk.PhotoImage(preview)
Frame2.configure(image=preview)
Frame2.image = preview
def cartoon(img):
edges1 = cv2.bitwise_not(cv2.Canny(img, 100, 200))
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
gray = cv2.medianBlur(gray, 5)
dst = cv2.edgePreservingFilter(img, flags=2, sigma_s=64, sigma_r=0.25)
cartoon1 = cv2.bitwise_and(dst, dst, mask=edges1)
return cartoon1
def cartoon():
image = cv2.imread(x)[:, :, ::-1]
global count, eimg
count = 4
if image is None:
print("can not find image")
exit()
image_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
image_gray = cv2.GaussianBlur(image_gray, (3, 3), 0)
image_edge = cv2.Laplacian(image_gray, -1, ksize=5)
image_edge = 255 - image_edge
ret, image_edge = cv2.threshold(image_edge, 150, 255, cv2.THRESH_BINARY)
edgePreservingImage = cv2.edgePreservingFilter(image,
flags=2,
sigma_s=50,
sigma_r=0.4)
global o4
output = np.zeros(image_gray.shape)
output = cv2.bitwise_and(edgePreservingImage,
edgePreservingImage,
mask=image_edge)
o4 = cv2.convertScaleAbs(output, alpha=1, beta=60)
image = Image.fromarray(o4)
eimg = image
image = ImageTk.PhotoImage(image)
panelB.configure(image=image)
panelB.image = image
def image_processing(img, filters):
filters = [{
'name': 'threshold',
'color': 'GRAY',
'low_tone': 0,
'high_tone': 255,
'type': ['THRESH_OTSU', 'THRESH_BINARY_INV'],
}, {
'name': 'gaussian_blur',
'width': 3,
'height': 3,
'sigmax': 0
}, {
'name': 'edge_pre_serv'
}]
for f in filters:
if f['name'] == 'gaussian_blur':
w, h, s = f['width'], f['height'], f['sigmax']
img = cv2.GaussianBlur(img, (w, h), s)
elif f['name'] == 'threshold':
l, h = f['low_tone'], f['high_tone']
_type = sum([getattr(cv2, x) for x in f['type']])
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
img = cv2.threshold(img, l, h, _type)[1]
elif f['name'] == 'edge_pre_serv':
img = cv2.edgePreservingFilter(img)
return img
def ice_blue(self):
new_image = cv2.applyColorMap(self.image, cv2.COLORMAP_OCEAN)
new_image = cv2.edgePreservingFilter(new_image,
flags=1,
sigma_s=70,
sigma_r=0.5)
return new_image
def generate_skin(self, img):
"""genrate skin table"""
rows, cols, channels = img.shape
current_img = copy.deepcopy(img) # get img data
current_img = cv2.edgePreservingFilter(img,
flags=1,
sigma_s=50,
sigma_r=0.5)
skin_table = np.ones(img.shape, np.uint8) # get data is 0 matrix
# self.skin_table = copy.deepcopy(self.current_img)
# Skin is identified by pixels
for r in range(rows):
for c in range(cols):
# get pixel value
B = img.item(r, c, 0)
G = img.item(r, c, 1)
R = img.item(r, c, 2)
# non-skin area if skin equals 0, skin area equals 1.
if (abs(R - G) > 15) and (R > G) and (R > B):
if (R > 95) and (G > 40) and (B > 20) and (
max(R, G, B) - min(R, G, B) > 15):
pass
elif (R > 220) and (G > 210) and (B > 170):
pass
else:
skin_table.itemset((r, c, 2), 0)
skin_table.itemset((r, c, 1), 0)
skin_table.itemset((r, c, 0), 0)
return skin_table
def __init__(self, imdb):
self.imdb = imdb
# all filters
self.filters = odict([
('Background Subtraction (mean)',
imdb.pipeline().use_window().single_bgsub3(method='mean')),
('Background Subtraction (median)',
imdb.pipeline().use_window().single_bgsub3(method='median')),
('Background Subtraction (min)',
imdb.pipeline().use_window().single_bgsub3(method='min')),
('Background Subtraction (max)',
imdb.pipeline().use_window().single_bgsub3(method='mean')),
('Original', imdb.pipeline()),
('Greyscale', imdb.pipeline().grey()),
('Edges', imdb.pipeline().grey().pipe(
lambda im: cv2.Laplacian(im, cv2.CV_64F)).invert()),
# https://www.learnopencv.com/non-photorealistic-rendering-using-opencv-python-c/
('Stylization', imdb.pipeline().pipe(
lambda im: cv2.stylization(im, sigma_s=10, sigma_r=0.4))),
('Pencil Sketch', imdb.pipeline().pipe(lambda im: cv2.pencilSketch(
im, sigma_s=10, sigma_r=0.1, shade_factor=0.02)[1])),
('Detail Enhance', imdb.pipeline().pipe(
lambda im: cv2.detailEnhance(im, sigma_s=20, sigma_r=0.15))),
('Edge Preserving',
imdb.pipeline().pipe(lambda im: cv2.edgePreservingFilter(
im, flags=1, sigma_s=30, sigma_r=0.4))),
])
for name in self.filters:
self.filters[name].fake_crop()
def makeCartoon(original):
# Make a copy of the origianl image to work with
img = np.copy(original)
# Convert image to grayscale
imgGray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# Apply gaussian filter to the grayscale image
imgGray = cv2.GaussianBlur(imgGray, (3, 3), 0)
# Detect edges in the image and threshold it
edges = cv2.Laplacian(imgGray, cv2.CV_8U, ksize=5)
edges = 255 - edges
ret, edgeMask = cv2.threshold(edges, 150, 255, cv2.THRESH_BINARY)
# Apply Edge preserving filter to get the heavily blurred image
imgBilateral = cv2.edgePreservingFilter(img,
flags=2,
sigma_s=50,
sigma_r=0.4)
# Create a outputmatrix
output = np.zeros(imgGray.shape)
# Combine the cartoon and edges
output = cv2.bitwise_and(imgBilateral, imgBilateral, mask=edgeMask)
return output
def cyberpunk_neon(self):
new_image = cv2.applyColorMap(self.image, cv2.COLORMAP_PLASMA)
new_image = cv2.edgePreservingFilter(new_image,
flags=1,
sigma_s=60,
sigma_r=0.4)
return new_image
def dehaze(I,
tmin=0.1,
w=15,
alpha=0.4,
omega=0.75,
p=0.1,
eps=1e-3,
reduce=False):
m, n, _ = I.shape
Idark, Ibright = get_illumination_channel(I, w)
A = get_atmosphere(I, Ibright, p)
init_t = get_initial_transmission(A, Ibright)
if reduce:
init_t = reduce_init_t(init_t)
corrected_t = get_corrected_transmission(I, A, Idark, Ibright, init_t,
alpha, omega, w)
normI = (I - I.min()) / (I.max() - I.min())
refined_t = guided_filter(normI, corrected_t, w, eps)
J_refined = get_final_image(I, A, refined_t, tmin)
enhanced = (J_refined * 255).astype(np.uint8)
f_enhanced = cv2.detailEnhance(enhanced, sigma_s=10, sigma_r=0.15)
f_enhanced = cv2.edgePreservingFilter(f_enhanced,
flags=1,
sigma_s=64,
sigma_r=0.2)
return f_enhanced
def enmascaradoPiola(img):
#Etapa uno, suavizar fondo e interior de las hojas preservado bordes
imgBlur = cv.edgePreservingFilter(img, flags=1, sigma_s=50, sigma_r=0.4)
#Deformo los colores preservando solo los bordes, dando un efecto de acuarela, lo q realza el borde
imgAc = cv.stylization(imgBlur, sigma_s=200, sigma_r=0.7)
#Paso a escala de grises
imgGray = cv.cvtColor(imgAc, cv.COLOR_BGR2GRAY)
#Filtrado para suavizar mas el fondo
imgG = cv.GaussianBlur(imgGray, (5, 5), 0.5)
#Expansion de bordes por dilatacion
ee = cv.getStructuringElement(cv.MORPH_RECT, (3, 3))
imgDil = cv.morphologyEx(imgG, cv.MORPH_DILATE, ee, iterations=1)
#Hago un filtrado de promedio para eliminar bordes internos de la hoja debido a la textura
img1Fil = cv.boxFilter(imgDil, -1, (5, 5))
#Binarizo con thresh adaptativo
img1Bin = cv.adaptiveThreshold(img1Fil, 255, cv.ADAPTIVE_THRESH_GAUSSIAN_C,
cv.THRESH_BINARY, 11, 1)
#Busqueda y dibujo de contornos
imgContornos = img.copy()
contours, _ = cv.findContours(img1Bin, cv.RETR_EXTERNAL,
cv.CHAIN_APPROX_NONE) #Contornos externos
cv.drawContours(imgContornos, contours, -1, (0, 0, 255), 2)
return contours
def rendering(image):
dst = cv2.edgePreservingFilter(image, flags=1, sigma_s=100, sigma_r=1.3)
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (15, 10))
dst2 = cv2.erode(dst,kernel)
return dst2
def edge_preserve(current_img, value=None):
if value is None:
value = np.random.random() * 4 + 1
value = value * 0.05
return cv2.edgePreservingFilter(current_img,
flags=1,
sigma_s=50,
sigma_r=value)
def sweet_dreams(self):
new_image = cv2.applyColorMap(self.image,
cv2.COLORMAP_TWILIGHT_SHIFTED)
new_image = cv2.edgePreservingFilter(new_image,
flags=1,
sigma_s=40,
sigma_r=0.6)
return new_image
def edge_preserving(A):
B = np.zeros((A.shape), dtype=np.float32)
for i in range(A.shape[0]):
B[i, :, :, :] = cv2.edgePreservingFilter(A[i, :, :, :],
flags=1,
sigma_s=30,
sigma_r=0.6)
return B
def edgePreserve(self, flags=1, sigma_s=50, sigma_r=0.15):
'''
flags: 边缘保持方法(迭代比归一化快), 1 -> 迭代滤波, 2 -> 归一化
'''
out = cv2.edgePreservingFilter(self.img,
flags=1,
sigma_s=50,
sigma_r=0.15)
self.showImage("edgePreservingFilter.png", out)
def edge_preserve(self):
if self.raw_image is None:
return 0
if self.ui.horizontalSlider_3.value() == 0:
self.current_img = self.raw_image
self.show_image()
return 0
value = self.ui.horizontalSlider_3.value() * 0.05
self.current_img = cv2.edgePreservingFilter(self.current_img, flags=1, sigma_s=50, sigma_r=value)
def find_contours(filepath,
contour_len_thresh=3,
nlevels=10,
min_val=20,
max_val=255,
resize_to=None):
if not isfile(filepath):
raise FileExistsError(f'Image file [{filepath}] does not exist')
im = cv2.imread(filepath)
scaled = im
if resize_to is not None:
h, w, c = im.shape
ratio = w / resize_to
new_size = tuple(
[int(round(v / ratio)) for v in [im.shape[1], im.shape[0]]])
scaled = cv2.resize(im, new_size)
dst = cv2.edgePreservingFilter(scaled, sigma_s=20, sigma_r=0.95)
imgray = cv2.cvtColor(dst, cv2.COLOR_BGR2GRAY)
blur = cv2.GaussianBlur(imgray, (9, 9), 0)
# FIND CONTOURS
contours_all = []
layers_all = []
threshvals = np.linspace(min_val, max_val, num=nlevels, dtype=np.int)
for t in threshvals:
ret, thresh = cv2.threshold(blur, t, 255, 0)
contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
order = [
v for i in sorted(set(hierarchy[0, :, 3]))
for v in np.where(hierarchy[0, :, 3] == i)[0]
]
layers = (hierarchy[0, :, 3] + 1) + (hierarchy[0, :, 0] + 1)
contours_all.extend([contours[i] for i in order])
layers_all.extend(layers)
if not len(contours_all):
raise NoContoursFound(
f'Failed to find contours in image file [{filepath}]')
#merged = list( zip(contours_all, layers_all))
#merged_sorted = sorted( merged, key = lambda m: m[1], reverse = False )
#contours_all = [ m[0] for m in merged_sorted ]
#contours_all =
fcnt = [c for c in contours_all if len(c) > contour_len_thresh]
if not len(contours_all):
raise NoContoursFound(
f'Failed to find contours with len > {contour_len_thresh} in image file [{filepath}]'
)
return dst, fcnt
def test_dt():
img = io.imread('../images/cow.jpg') / 255.0
original = np.copy(img)
# the opencv function
dst = cv2.edgePreservingFilter(src, flags=1, sigma_s=60, sigma_r=0.4)
# typ =np.info(img.dtype).max #in case of a binary image
img = img.astype(np.float32)
img_bilateral = cv2.bilateralFilter(img, 5, 50, 50)
denoised_img = denoise(img)
show_images([img, img_bilateral, denoised_img])
def main():
src = cv.imread("../../pic/IMG_20191204_151110.jpg")
cv.namedWindow("src", cv.WINDOW_AUTOSIZE)
cv.imshow("src", src)
dst = cv.edgePreservingFilter(src,
sigma_s=100,
sigma_r=0.4,
flags=cv.RECURS_FILTER)
cv.imshow("dst", dst)
cv.waitKey(0)
cv.destroyAllWindows()
def cartoon(self):
img = self.image
edges1 = cv2.bitwise_not(cv2.Canny(img, 100, 200))
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
gray = cv2.medianBlur(gray, 5)
edges2 = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_MEAN_C,
cv2.THRESH_BINARY, 7, 7)
dst = cv2.edgePreservingFilter(img, flags=2, sigma_s=64, sigma_r=0.25)
cartoon1 = cv2.bitwise_and(dst, dst, mask=edges1)
cartoon2 = cv2.bitwise_and(dst, dst, mask=edges2)
return cartoon2
def __init__(self, Canvas, window_title, AskLayerNames=True, CorrectXYWhileSelecting=True, RegionMovable=True):
super().__init__(Canvas, window_title, AskLayerNames=AskLayerNames, CorrectXYWhileSelecting=CorrectXYWhileSelecting, RegionMovable=RegionMovable)
# Tolerance value to be used
self.Tolerance = 32
# Seed point coordinates
self.seed = None
# Mask image of the selected region
self.Mask = np.zeros((self.CanvasShape[0], self.CanvasShape[1], 1), dtype=np.uint8)
# Image to be worked on
self.WorkingImage = cv2.edgePreservingFilter(self.CombinedFrame.copy(), flags=1, sigma_s=11, sigma_r=0.2)
self.WorkingImage = cv2.cvtColor(self.WorkingImage, cv2.COLOR_BGR2GRAY)
def transform(self, renderer_type_id):
print("transform {}".format(renderer_type_id))
try:
src_image = self.get_opencv_image()
self.transformed_image = None
if src_image.any() != None:
if renderer_type_id == MainView.EdgePreserveSmoothingByNormalizedConvolutionFilter:
self.transformed_image = cv2.edgePreservingFilter(
src_image, flags=1)
if renderer_type_id == MainView.EdgePreserveSmoothingByRecursiveFilter:
self.transformed_image = cv2.edgePreservingFilter(
src_image, flags=2)
if renderer_type_id == MainView.DetailEnhancement:
self.transformed_image = cv2.detailEnhance(src_image)
if renderer_type_id == MainView.MonochromePencilSketch:
self.transformed_image, _ = cv2.pencilSketch(
src_image,
sigma_s=10,
sigma_r=0.1,
shade_factor=0.03)
if renderer_type_id == MainView.ColorPencilSketch:
_, self.transformed_image = cv2.pencilSketch(
src_image,
sigma_s=10,
sigma_r=0.1,
shade_factor=0.03)
if renderer_type_id == MainView.Stylization:
self.transformed_image = cv2.stylization(src_image)
if self.transformed_image.all() != None:
self.set_opencv_image(self.transformed_image)
self.update()
except:
traceback.print_exc()
def filter(self, sigmaColor, sigmaSpace):
if self.source_image.all() != None:
flag = cv2.RECURS_FILTER
filtered_image = cv2.edgePreservingFilter(
self.source_image,
flag,
sigma_s=sigmaSpace,
sigma_r=float(sigmaColor) / 100.0)
self.set_opencv_image(filtered_image)
self.update()
def main(args):
image_in = cv2.imread(args.fname_input)
image_out = cv2.edgePreservingFilter(image_in)
image_out, _ = cv2.pencilSketch(image_out, sigma_r=0.09, shade_factor=0.05)
if args.visualize:
image_out = cv2.cvtColor(image_out, cv2.COLOR_GRAY2RGB)
image_both = np.hstack((image_in, image_out))
cv2.imshow('Pencil sketch', image_both)
cv2.waitKey(0)
cv2.imwrite(args.fname_output, image_out)
def find_contours_canny(filepath,
contour_len_thresh=5,
nlevels=10,
min_val=20,
max_val=255,
resize_to=None,
remove_duplicates=False):
if not isfile(filepath):
raise FileExistsError(f'Image file [{filepath}] does not exist')
im = cv2.imread(filepath)
scaled = im
if resize_to is not None:
h, w, c = im.shape
ratio = w / resize_to
new_size = tuple(
[int(round(v / ratio)) for v in [im.shape[1], im.shape[0]]])
scaled = cv2.resize(im, new_size)
# Filter to generate color regions
blur_bgr = cv2.edgePreservingFilter(scaled, sigma_s=20, sigma_r=0.95)
# blur_bgr = cv2.stylization(im, sigma_s=20, sigma_r=0.95)
imgray = cv2.cvtColor(blur_bgr, cv2.COLOR_BGR2GRAY)
kernel = np.ones((3, 3), np.uint8)
threshvals = np.linspace(min_val, max_val, num=nlevels, dtype=np.int)
layered = np.zeros(imgray.shape)
for i, t in enumerate(threshvals):
ret, thresh = cv2.threshold(imgray, t, min(250, t + 100), 0)
canny = cv2.Canny(thresh, t, min(250, t + 100))
ret, thresh = cv2.threshold(canny, t, 255, 0)
layered = np.array(np.clip(layered + thresh, 0, 255), dtype=np.uint8)
layered = cv2.GaussianBlur(layered, (1, 1), 0)
layered = cv2.morphologyEx(layered, cv2.MORPH_CLOSE, kernel)
# Morphology and some blurring to clean the lines
layered = cv2.GaussianBlur(layered, (3, 3), 0)
layered = cv2.morphologyEx(layered, cv2.MORPH_OPEN, kernel)
layered = cv2.morphologyEx(layered, cv2.MORPH_CLOSE, kernel)
contours, hierarchy = cv2.findContours(layered, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
if not len(contours):
raise NoContoursFound(
f'Failed to find contours in image file [{filepath}]')
return blur_bgr, contours
def _cartoon(orig):
img = np.copy(orig)
img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
img_gray = cv2.GaussianBlur(img_gray, (3, 3), 0)
edges = cv2.Laplacian(img_gray, cv2.CV_8U, ksize=5)
edges = 255 - edges
ret, edge_mask = cv2.threshold(edges, 150, 255, cv2.THRESH_BINARY)
img_bilateral = cv2.edgePreservingFilter(img,
flags=2,
sigma_s=50,
sigma_r=0.4)
output = np.zeros(img_gray.shape)
output = cv2.bitwise_and(img_bilateral, img_bilateral, mask=edge_mask)
return output
def edge_detection(img_grabcut):
gray = cv2.cvtColor(img_grabcut, cv2.COLOR_BGR2GRAY)
_, gray = cv2.threshold(gray, 120, 255, cv2.THRESH_TOZERO)
gray = cv2.GaussianBlur(gray, (7, 7), 0)
gray = cv2.bilateralFilter(gray, 9, 75, 75)
gray = cv2.edgePreservingFilter(gray, flags=1, sigma_s=45, sigma_r=0.2)
edged = cv2.Canny(gray, 75, 200, True)
#cv2.imshow("grayscale", gray)
cv2.imshow("edged", edged)
return edged
async def hehe(event):
if not event.reply_to_msg_id:
await event.reply("Reply to any Image.")
return
reply = await event.get_reply_message()
await event.edit('`Processing...`')
image = await bot.download_media(reply.media, path)
img = cv2.VideoCapture(image)
ret, frame = img.read()
smooth = cv2.edgePreservingFilter(frame, flags=1, sigma_s=60, sigma_r=0.4)
cv2.imwrite("danish.jpg", smooth)
await event.client.send_file(event.chat_id, "danish.jpg", force_document=False, reply_to=event.reply_to_msg_id)
await event.delete()
shutil.rmtree(path)
os.remove("danish.jpg")
'''
OpenCV Non-Photorealistic Rendering Python Example
Copyright 2015 by Satya Mallick <*****@*****.**>
'''
import cv2
# Read image
im = cv2.imread("cow.jpg");
# Edge preserving filter with two different flags.
imout = cv2.edgePreservingFilter(im, flags=cv2.RECURS_FILTER);
cv2.imwrite("edge-preserving-recursive-filter.jpg", imout);
imout = cv2.edgePreservingFilter(im, flags=cv2.NORMCONV_FILTER);
cv2.imwrite("edge-preserving-normalized-convolution-filter.jpg", imout);
# Detail enhance filter
imout = cv2.detailEnhance(im);
cv2.imwrite("detail-enhance.jpg", imout);
# Pencil sketch filter
imout_gray, imout = cv2.pencilSketch(im, sigma_s=60, sigma_r=0.07, shade_factor=0.05);
cv2.imwrite("pencil-sketch.jpg", imout_gray);
cv2.imwrite("pencil-sketch-color.jpg", imout);
# Stylization filter
cv2.stylization(im,imout);
cv2.imwrite("stylization.jpg", imout);
def sketch_img(img):
# outimg = cv2.stylization(img, sigma_s=60, sigma_r=0.07)
outimg = cv2.edgePreservingFilter(img, flags=1, sigma_s=60, sigma_r=0.4)
outimg = cv2.detailEnhance(outimg, sigma_s=10, sigma_r=0.15)
dst_gray, dst_color = cv2.pencilSketch(outimg, sigma_s=60, sigma_r=0.07, shade_factor=0.05)
return dst_gray
