def gauss_filt_3x3():
if request.method == "POST":
try:
delete_images()
image_src = 'static/uploads/img.png'
im = Image.open(image_src)
# Masca Gauss 3x3 fara coeficientul 1/16
gauss_mask = (
1,
2,
1,
2,
4,
2,
1,
2,
1,
)
im_gauss = im.filter(
ImageFilter.Kernel((3, 3), gauss_mask, scale=16)
) # scale reprezinta la cat se imparte gauss_mask (suma elementelor din ea)
im_gauss.save('static/uploads/img_gauss_3x3.png')
image_url_gauss = url_for('static',
filename="uploads/img_gauss_3x3.png")
return jsonify({'image_url_gauss_3x3': image_url_gauss})
except Exception as e:
print(e)
def cropper():
if request.method == "POST":
delete_images()
image_src = 'static/uploads/img.png'
im = Image.open(image_src)
width, height = im.size # Latimea si inaltimea imaginii
box = request.get_data(as_text=True)
# Datele primite sunt separate in left, upper, right, lower si stocate toate intr-un tuple
box = box.split('&')
box_left = box.pop(0)
print(box_left)
box_left = box_left.split('=')
box_left = int(
box_left.pop()
) * width / 100 # Datele primite de la client sunt transformate din procente in dimensiuni in pixeli ale imaginii
box_upper = box.pop(0)
box_upper = box_upper.split('=')
box_upper = int(box_upper.pop()) * height / 100
box_right = box.pop(0)
box_right = box_right.split('=')
box_right = int(box_right.pop()) * width / 100
box_lower = box.pop(0)
box_lower = box_lower.split('=')
box_lower = int(box_lower.pop()) * height / 100
box_tuple = box_left, box_upper, box_right, box_lower # Tuple-ul unde sunt memorate datele modificate
im_crop = im.crop(
box_tuple
) # Se taie imaginea dupa coordonatele imaginii stanga,sus,dreapta,jos
imgname = 'img_crop_' + str(box_tuple[0]) + str(box_tuple[1]) + str(
box_tuple[2]) + str(box_tuple[3]) + '.png'
im_crop.save('static/uploads/' + imgname)
image_url_crop = url_for('static', filename="uploads/" + imgname)
return jsonify({'image_url_crop': image_url_crop})
def kirsch_filt_N():
if request.method == "POST":
try:
delete_images()
image_src = 'static/uploads/img.png'
im = Image.open(image_src).convert(
mode="L") # convertire in imagine monocroma
# Masca Kirsch nord pentru detectarea conturului fara coeficientul 1/15
kirsch_mask = (
3,
3,
3,
3,
0,
3,
-5,
-5,
-5,
)
im_kirsch = im.filter(
ImageFilter.Kernel((3, 3), kirsch_mask, scale=15)
) # scale => coeficientul 1/15 al kirsch_mask (se aduna toate elemente pozitive din masca => 15)
im_kirsch.save('static/uploads/img_kirsch_N.png')
image_url_kirsch = url_for('static',
filename="uploads/img_kirsch_N.png")
return jsonify({'image_url_kirsch_N': image_url_kirsch})
except Exception as e:
print(e)
def im2bw():
if request.method == "POST":
try:
delete_images()
image_src = 'static/uploads/img.png'
im = Image.open(image_src).convert(
mode="L") # imaginea devine monocroma
pixels = np.array(im,
dtype=np.uint8) # matricea pixelilor imaginii
prag = int(request.get_data())
imgname = "img_bw_" + str(
prag
) + ".png" # numele imaginii va fi alcatuit din img_bw_ + valoarea pragului
y, x = im.size # dimensiunile imaginii
for i in range(x):
for j in range(y):
# ce este peste prag devine alb, ce este sub prag, devine negru
if pixels[i][j] >= prag:
pixels[i][j] = 255
else:
pixels[i][j] = 0
im_bw = Image.fromarray(
pixels
) # transformare din matricea de pixeli (numere) in imagine binara
im_bw.save('static/uploads/' + imgname)
image_url_bw = url_for('static', filename="uploads/" + imgname)
return jsonify({'image_url_bw': image_url_bw})
except Exception as e:
print(e)
def kirsch_filt_S():
if request.method == "POST":
try:
delete_images()
image_src = 'static/uploads/img.png'
im = Image.open(image_src).convert(mode="L")
kirsch_mask = (
-5,
-5,
-5,
3,
0,
3,
3,
3,
3,
)
im_kirsch = im.filter(
ImageFilter.Kernel((3, 3), kirsch_mask, scale=15))
im_kirsch.save('static/uploads/img_kirsch_S.png')
image_url_kirsch = url_for('static',
filename="uploads/img_kirsch_S.png")
return jsonify({'image_url_kirsch_S': image_url_kirsch})
except Exception as e:
print(e)
def unsharp():
if request.method == "POST":
delete_images()
image_src = 'static/uploads/img.png'
im = Image.open(image_src)
trio = request.get_data(as_text=True)
# Datele primite sunt separate in radius, strength, threshold si stocate toate intr-un tuple
trio = trio.split('&')
trio_radius = trio.pop(0)
trio_radius = trio_radius.split('=')
trio_radius = int(trio_radius.pop())
trio_strength = trio.pop(0)
trio_strength = trio_strength.split('=')
trio_strength = int(trio_strength.pop())
trio_threshold = trio.pop(0)
trio_threshold = trio_threshold.split('=')
trio_threshold = int(trio_threshold.pop())
im_unsharp = im.filter(
ImageFilter.UnsharpMask(trio_radius, trio_strength,
trio_threshold))
imgname = 'img_unsharp_' + str(trio_radius) + str(trio_strength) + str(
trio_threshold) + '.png'
im_unsharp.save('static/uploads/' + imgname)
image_url_unsharp = url_for('static', filename="uploads/" + imgname)
return jsonify({'image_url_unsharp': image_url_unsharp})
def unif_filt_3x3():
if request.method == "POST":
try:
delete_images()
image_src = 'static/uploads/img.png'
im = Image.open(image_src)
# Masca uniforma 3x3 fara coeficientul 1/9
uniform_mask = (
1,
1,
1,
1,
1,
1,
1,
1,
1,
)
im_unif = im.filter(
ImageFilter.Kernel((3, 3), uniform_mask, scale=9)
) # scale reprezinta la cat se imparte uniform_mask (suma elementelor din ea)
im_unif.save('static/uploads/img_unif_3x3.png')
image_url_unif = url_for('static',
filename="uploads/img_unif_3x3.png")
return jsonify({'image_url_unif_3x3': image_url_unif})
except Exception as e:
print(e)
def roberts_filt_S():
if request.method == "POST":
try:
delete_images()
image_src = 'static/uploads/img.png'
im = Image.open(image_src).convert(mode="L")
# Masca Roberts sud pentru detectarea conturului
roberts_mask = (
0,
0,
0,
0,
-1,
0,
0,
1,
0,
)
im_roberts = im.filter(
ImageFilter.Kernel((3, 3), roberts_mask, scale=1))
im_roberts.save('static/uploads/img_roberts_S.png')
image_url_roberts = url_for('static',
filename="uploads/img_roberts_S.png")
return jsonify({'image_url_roberts_S': image_url_roberts})
except Exception as e:
print(e)
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 emboss_image():
if request.method == "POST":
delete_images()
image_src = 'static/uploads/img.png'
im = Image.open(image_src)
im = im.filter(ImageFilter.EMBOSS) # Imprima in relief imaginea
im.save('static/uploads/img.png')
image_url_emboss = url_for('static', filename="uploads/img.png")
return jsonify({'image_url_emboss': image_url_emboss})
def detail_image():
if request.method == "POST":
delete_images()
image_src = 'static/uploads/img.png'
im = Image.open(image_src)
im = im.filter(ImageFilter.DETAIL) # Indetaliaza imaginea
im.save('static/uploads/img.png')
image_url_detail = url_for('static', filename="uploads/img.png")
return jsonify({'image_url_detail': image_url_detail})
def equalizer():
if request.method == "POST":
delete_images()
image_src = 'static/uploads/img.png'
im = Image.open(image_src)
im = ImageOps.equalize(im) # Egalizeaza histograma imaginei
im.save('static/uploads/img.png')
image_url_equalize = url_for('static', filename="uploads/img.png")
return jsonify({'image_url_equalize': image_url_equalize})
def rgb2gray():
if request.method == "POST":
delete_images()
image_src = 'static/uploads/img.png'
im_gray = Image.open(image_src).convert(
mode='L') # Transformam imaginea din RGB in monocrom
im_gray.save('static/uploads/img_rgb2gray.png')
image_url_gray = url_for('static', filename="uploads/img_rgb2gray.png")
return jsonify({'image_url_gray': image_url_gray})
def blur_image():
if request.method == "POST":
delete_images()
image_src = 'static/uploads/img.png'
im = Image.open(image_src)
im = im.filter(ImageFilter.BLUR) # Micsoreaza claritatea imaginii
im.save('static/uploads/img.png')
image_url_blur = url_for('static', filename="uploads/img.png")
return jsonify({'image_url_blur': image_url_blur})
def sharpen_image():
if request.method == "POST":
delete_images()
image_src = 'static/uploads/img.png'
im = Image.open(image_src)
im = im.filter(ImageFilter.SHARPEN) # Mareste claritatea imaginii
im.save('static/uploads/img.png')
image_url_sharpen = url_for('static', filename="uploads/img.png")
return jsonify({'image_url_sharpen': image_url_sharpen})
def flip_image():
if request.method == "POST":
delete_images()
image_src = 'static/uploads/img.png'
im = Image.open(image_src)
im = ImageOps.flip(im) # Intoarce imaginea vertical (de sus in jos)
im.save('static/uploads/img.png')
image_url_flip = url_for('static', filename="uploads/img.png")
return jsonify({'image_url_flip': image_url_flip})
def smooth_image():
if request.method == "POST":
delete_images()
image_src = 'static/uploads/img.png'
im = Image.open(image_src)
im = im.filter(ImageFilter.SMOOTH) # Netezeste imaginea
im.save('static/uploads/img.png')
image_url_smooth = url_for('static', filename="uploads/img.png")
return jsonify({'image_url_smooth': image_url_smooth})
def contour_image():
if request.method == "POST":
delete_images()
image_src = 'static/uploads/img.png'
im = Image.open(image_src)
im = im.filter(ImageFilter.CONTOUR
) # Accentueaza conturul elementelor din imagine
im.save('static/uploads/img.png')
image_url_contour = url_for('static', filename="uploads/img.png")
return jsonify({'image_url_contour': image_url_contour})
def edge_enhance_image():
if request.method == "POST":
delete_images()
image_src = 'static/uploads/img.png'
im = Image.open(image_src)
im = im.filter(
ImageFilter.EDGE_ENHANCE) # Accentueaza marginile din imagine
im.save('static/uploads/img.png')
image_url_edge_enhance = url_for('static', filename="uploads/img.png")
return jsonify({'image_url_edge_enhance': image_url_edge_enhance})
def invert_image():
if request.method == "POST":
delete_images()
image_src = 'static/uploads/img.png'
im = Image.open(image_src)
im = ImageOps.invert(
im) # Inverseaza culorile imaginii => negativul imaginii
im.save('static/uploads/img.png')
image_url_invert = url_for('static', filename="uploads/img.png")
return jsonify({'image_url_invert': image_url_invert})
def rotate_90_image():
if request.method == "POST":
delete_images()
image_src = 'static/uploads/img.png'
im = Image.open(image_src)
im = im.transpose(
method=Image.ROTATE_90) # Roteste imaginea cu 90 grade
im.save('static/uploads/img.png')
image_url_rotate_90 = url_for('static', filename="uploads/img.png")
return jsonify({'image_url_rotate_90': image_url_rotate_90})
def autocont():
if request.method == "POST":
delete_images()
image_src = 'static/uploads/img.png'
im = Image.open(image_src)
im = ImageOps.autocontrast(
im
) # Selecteaza cel mai luminos pixel si il face alb, si cel mai intunecat pixel si il face negru, restul se normalizeaza
im.save('static/uploads/img.png')
image_url_autocont = url_for('static', filename="uploads/img.png")
return jsonify({'image_url_autocont': image_url_autocont})
def mirror_image():
if request.method == "POST":
delete_images()
image_src = 'static/uploads/img.png'
im = Image.open(image_src)
im = ImageOps.mirror(
im
) # Intoarce imaginea orizontal (in oglinda, de la stanga la dreapta)
im.save('static/uploads/img.png')
image_url_mirror = url_for('static', filename="uploads/img.png")
return jsonify({'image_url_mirror': image_url_mirror})
def gblur():
if request.method == "POST":
delete_images()
image_src = 'static/uploads/img.png'
im = Image.open(image_src)
radius = int(request.get_data()) # reprezinta raza blur-ului
im_gblur = im.filter(
ImageFilter.GaussianBlur(radius)) # filtrul de Gaussian Blur
imgname = 'img_gblur_' + str(radius) + '.png'
im_gblur.save('static/uploads/' + imgname)
image_url_gblur = url_for('static', filename="uploads/" + imgname)
return jsonify({'image_url_gblur': image_url_gblur})
def contrast():
if request.method == "POST":
delete_images()
image_src = 'static/uploads/img.png'
im = Image.open(image_src)
enhancer = ImageEnhance.Contrast(im)
factor = int(request.get_data()) * 2 / 100
imgname = 'img_contrast_' + str(factor) + '.png'
im_contrast = enhancer.enhance(factor)
im_contrast.save('static/uploads/' + imgname)
image_url_contrast = url_for('static', filename="uploads/" + imgname)
return jsonify({'image_url_contrast': image_url_contrast})
def sharp():
if request.method == "POST":
delete_images()
image_src = 'static/uploads/img.png'
im = Image.open(image_src)
enhancer = ImageEnhance.Sharpness(im)
factor = int(request.get_data()) * 2 / 100
imgname = 'img_sharp_' + str(factor) + '.png'
im_sharp = enhancer.enhance(factor)
im_sharp.save('static/uploads/' + imgname)
image_url_sharp = url_for('static', filename="uploads/" + imgname)
return jsonify({'image_url_sharp': image_url_sharp})
def rotate_image():
if request.method == "POST":
delete_images()
image_src = 'static/uploads/img.png'
im = Image.open(image_src)
factor = int(request.get_data()) # reprezinta unghiul de rotatie
im_rotate = im.rotate(
angle=factor, expand=True, fillcolor='#FFFFFF'
) # fundalul de umplere va fi alb, iar imaginea initiala isi va pastra dimensiunile
imgname = 'img_rotate_' + str(factor) + '.png'
im_rotate.save('static/uploads/' + imgname)
image_url_rotate = url_for('static', filename="uploads/" + imgname)
return jsonify({'image_url_rotate': image_url_rotate})
def min_filter():
if request.method == "POST":
try:
delete_images()
image_src = 'static/uploads/img.png'
im = Image.open(image_src)
im_min = im.filter(ImageFilter.MinFilter(
size=3)) # Se alege pixelul minim dintr-un bloc de pixeli 3x3
im_min.save('static/uploads/img_min.png')
image_url_min = url_for('static', filename="uploads/img_min.png")
return jsonify({'image_url_min': image_url_min})
except Exception as e:
print(e)
def scalare():
if request.method == "POST":
delete_images()
image_src = 'static/uploads/img.png'
im = Image.open(image_src)
# Convertim datele primite care apartin [0,100] in date care apartin [0,2]
# Pentru factor = 1 imaginea este cea originala, valori din ce in ce mai mici (<1) imaginea se micsoreaza
# si pentru valori din ce in ce mai mari (>1) imaginea se mareste
factor = int(request.get_data()) * 2 / 100
im_scale = ImageOps.scale(im, factor)
imgname = 'img_scale_' + str(factor) + '.png'
im_scale.save('static/uploads/' + imgname)
image_url_scale = url_for('static', filename="uploads/" + imgname)
return jsonify({'image_url_scale': image_url_scale})
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)
