def ricolora(fname, lista, fnameout):
im = immagini.load(fname)
imcopy = immagini.load(fname)
row = len(im)
col = len(im[0])
k = 1
ListCount = []
for listin in lista:
k += 1
x = listin[0]
y = listin[1]
c1 = listin[2]
c2 = listin[3]
countc1 = 0
countc2 = 0
color_x = im[x][y]
listpix = []
listpix.append((x, y))
i = 0
while (i < len(listpix)):
#print(len(listpix))
x = listpix[i][0]
y = listpix[i][1]
imcopy, listpix, countc1, countc2 = check_color(
im, x, y, color_x, c1, c2, listpix, imcopy, countc1, countc2)
i += 1
ListCount.append((countc1, countc2))
if (fnameout in ['test7.png', 'test6.png']):
im = imcopy
immagini.save(imcopy, fnameout)
return ListCount
def misure():
A = immagini.load("Ist0.png")
print("L'immagine Ist0.png e' " + str(len(A)) + " X " + str(len(A[0])))
A = immagini.load("Ist1.png")
print("L'immagine Ist1.png e' " + str(len(A)) + " X " + str(len(A[0])))
A = immagini.load("Ist2.png")
print("L'immagine Ist2.png e' " + str(len(A)) + " X " + str(len(A[0])))
A = immagini.load("Ist3.png")
print("L'immagine Ist3.png e' " + str(len(A)) + " X " + str(len(A[0])))
A = immagini.load("Ist4.png")
print("L'immagine Ist4.png e' " + str(len(A)) + " X " + str(len(A[0])))
def quadrato(filename, c):
img = load(filename)
latof = 0
for x in range(len(img)):
for y in range(len(img[0])):
x, y = inizio(img, c, x, y)
xi = x
yi = y
while inside(img, y, x) and img[x][y] == c:
y += 1
x += 1
xf = x - 1
yf = y - 1
pieno(xf, yf, xi, yi, x, y, img, c)
lato = (xf - xi + 1)
if lato > latof:
latof = lato
xfinale = xi
yfinale = yi
if yi < len(img[0]) - 1:
y = yi + 1
x = xi
elif xi < len(img) - 1:
y = 0
x = xi + 1
else:
break
return latof, (yfinale, xfinale)
def ricolora(fname, lista, fnameout):
img, res = load(fname), []
w, h = len(img[0]), len(img)
for qdp in lista:
res.append(paintPx(qdp[1], qdp[0], img, qdp[2], qdp[3], w, h))
save(img, fnameout)
return res
def es4(fimm, fimm1, h1, w1):
'''
Si definisca la funzione es4(fimm,fimm1) che,
- riceve gli indirizzi fimm e fimm1 di due file .PNG. e due interi h1 e w1 maggiori di zero.
- legge l'immagine da fimm e crea una seconda immagine. L'immagine da creare
ha h1 volte la lunghezza di quella letta e w1 volte la larghezza di quella letta e si ottiene
sostituendo ad ogni pixel dell'immagine letta un rettangolo di pixels di altezza h e ampiezza w aventi
tutti il colore del pixel originario.
- salva l'immagine creata all'indirizzo fimm.
- restituisce la tupla con il colore che compare piu' spesso nell'immagine letta e in
caso di parita' di occorrenze massime il colore del pixel che viene prima lessicograficamente.
Per caricare e salvare i file PNG si possono usare load e save della libreria immagini.
'''
img = immagini.load(fimm)
newImg = []
occurrencesDict = dict()
for row in range(len(img)):
newRow = []
for col in range(len(img[0])):
pixel = img[row][col]
occurrencesDict[pixel] = occurrencesDict.get(pixel, 0) + 1
for i in range(w1):
newRow.append(pixel)
for i in range(h1):
newImg.append(newRow)
immagini.save(newImg, fimm1)
occ = list(sorted(sorted(occurrencesDict.keys()), key = occurrencesDict.get, reverse = True))
return occ[0]
def es1(fimm, k):
count = 0
img = immagini.load(fimm)
red = (255, 0, 0)
if hasGrid(img):
grid, side = getGrid(img)
else:
return 0
for r in range(0, len(grid) - (k * (side + 1)), side + 1):
for c in range(0, len(grid[0]) - (k * (side + 1)), side + 1):
x, y = c, r
xUR = c + k * (side + 1)
yBL = r + k * (side + 1)
for idx in range(k):
if (grid[r][x + 1] == grid[y + 1][c] == grid[y + 1][xUR] ==
grid[yBL][x + 1] == red):
if idx == k - 1:
count += 1
else:
x += side + 1
y += side + 1
else:
break
return count
def ricolora(fname, lista, fnameout):
image = immagini.load(fname)
returnValue = []
def fill(y, x):
queue = deque([(y, x)])
visited = set()
border = set()
image_len_y = len(image)
image_len_x = len(image[0])
def valid(t, q):
if t in visited:
return False
elif t in queue:
return False
elif t[0] < 0 or t[1] < 0:
border.add(q)
return False
elif t[1] >= image_len_x or t[0] >= image_len_y:
border.add(q)
return False
elif image[t[0]][t[1]] != image[q[0]][q[1]]:
border.add(q)
return False
else:
return True
while queue:
q = queue[0]
visited.add(q)
if valid((q[0], q[1] + 1), q):
queue.append((q[0], q[1] + 1))
if valid((q[0] + 1, q[1]), q):
queue.append((q[0] + 1, q[1]))
if valid((q[0], q[1] - 1), q):
queue.append((q[0], q[1] - 1))
if valid((q[0] - 1, q[1]), q):
queue.append((q[0] - 1, q[1]))
image[q[0]][q[1]] = color1
queue.popleft()
area = len(visited) - len(border)
for p in border:
image[p[0]][p[1]] = color2
return area, len(border)
for i in lista:
x = i[0]
y = i[1]
color1 = i[2]
color2 = i[3]
counter = fill(y, x)
returnValue.append(counter)
immagini.save(image, fnameout)
return returnValue
def quadrato(filename,c):
img=load(filename)
listax=[]
listay=[]
for y in range(len(img[1])):
for x in range(len(img[0])):
try:
if img[y][x]==c:
lato=quadx(img,x,y,c)
listax.append(lato)
if img[x][y]==c:
lato=quady(img,x,y,c)
listay.append(lato)
except IndexError:
pass
insx=set(listax)
insy=set(listay)
side=insx.intersection(insy)
side=max(side)
for y in range(len(img[1])):
for x in range(len(img[0])):
try:
if side==1 and img[y][x]==c:
result=(side,(x,y))
return result
if img[y][x]==c and mislato(img,x,y,side,c):
result=(side,(x-10,y+19))
return result
except IndexError:
pass
result=(side,(x,y))
def cammino(fname, fname1):
im=immagini.load(fname)
row=len(im)
col=len(im[0])
str_result=''
loc_now=[39,39]
x=40
arrow=0
im=change_color(im,loc_now,(0,255,0))
while(arrow>=0):
#check Right
if(arrow==0):
loc_now[1]=loc_now[1]+x
str_result+='0'
elif( (arrow==1)):
loc_now[0]=loc_now[0]+x
str_result+='1'
elif((arrow==2)):
loc_now[1]=loc_now[1]-x
str_result+='2'
elif((arrow==3)):
loc_now[0]=loc_now[0]-x
str_result+='3'
else:
break
im=change_color(im,loc_now,(0,255,0))
arrow=change_arrow(im,arrow,loc_now,x)
im=change_color(im,loc_now,(0,0,255))
immagini.save(im,fname1)
return str_result
def quadrato(filename, c):
img = load(filename)
righe = len(img)
colonne = len(img[0])
start = 0
for k in range(righe):
for p in range(colonne):
if not img[k][p] == c:
continue
par = 1
Bool = True
for x in range(p + 1, colonne):
if not img[k][x] != c:
par += 1
else:
break
if par > start:
for y in range(k + 1, k + par):
for x in range(p, p + par):
if img[y][x] != c:
Bool = False
break
if Bool == False:
break
if Bool and par > start:
pixel = (p, k)
start = par
return start, pixel
def es1(fimm,k):
img = immagini.load(fimm) #Contiene l'immagine caricata
width = len(img[0]) #Contiene la larghezza dell'immagine
height = len(img) #Contiene l'altezza dell'immagine
gap = 0 #Contiene quanti pixel di gap ci sono tra un punto della griglia e l'altro
right_boundary_index = None #Contiene la posizione in cui si trova l'ultimo pixel della griglia a destra
bottom_boundary_index = None #Contiene la posizione in cui si trova l'ultimo pixel della griglia in basso
x_starting_index = None #Contiene la posizione in cui si trova l'indice x del primo pixel
y_starting_index = None #Contiene la posizione in cui si trova l'indice y del primo pixel
y_index, x_index, x_starting_index, y_starting_index = first_grid_node(img,height,width)
if x_starting_index == None: #Se il primo pixel della griglia non è stato trovato...
return 0 #...allora la griglia è vuota, restituisci 0
right_boundary_index, gap = get_gap(img, x_index, y_index, x_starting_index, y_starting_index, width, height)
if not gap: #Se il gap non è stato ancora trovato
if k: #Se k è un numero diverso da 0
return 0 #...allora restituisci zero
else:
return 1 #...altrimenti restituisci uno
if not right_boundary_index == x_starting_index: #Se la griglia NON è larga uno...:
right_boundary_index = get_right_boundary(img, x_starting_index, y_starting_index, width, gap) #Ottiieni l'ultimo pixel destro della griglia
bottom_boundary_index = get_bottom_boundary(img, x_starting_index, y_starting_index, height, gap) #Ottieni l'ultimo pixel inferiore della griglia
ins = get_possible_x_segments(img, x_starting_index, y_starting_index, right_boundary_index, bottom_boundary_index, gap, k) #Ottiene la lista dei possibili quadrati
if not len(ins): #Se l'insieme è vuoto...
return 0 #...allora restituisci 0
if len(ins) > ((right_boundary_index-x_starting_index)//gap-k) * ((bottom_boundary_index-y_starting_index)//gap) // 8: #Se ci sono parecchi possibili quadrati allora utilizza un metodo alternativo e in questo caso più rapido
ins_y = get_possible_y_segments(img, x_starting_index, y_starting_index, right_boundary_index, bottom_boundary_index, gap, k) #Insieme
return count_intersection(ins,ins_y,k) #Restituisce il numero dei quadrati
return count_squares(img, ins,x_starting_index, y_starting_index, gap,k) #Restituisce il numero dei quadrati
def quadrato(filename, c):
A = immagini.load(filename)
righe = len(A)
colonne = len(A[0])
S = set()
for i in range(righe):
for j in range(colonne):
if A[i][j] == c:
S.add((i, j))
d = 0 # dimensione iniziale del lato del quadrato
a = b = -1 # coordinate del punto in alto a sinistra da cui parte il quadrato da individuare
for r1 in range(righe):
for c1 in range(colonne):
if (r1, c1) in S:
W = set()
W.add((r1, c1))
S = S - W
dx = lato(S, r1, c1)
if (dx > d) or (dx == d and r1 < a) or (dx == d and r1 == a
and c1 < b):
d = dx
a = r1
b = c1
# righe = len(A) - dx
# colonne = len(A[0]) - dx
# c1 = c1 + 1
# r1 = r1 + 1
return (d, (b, a))
def quadrato(filename,c):
src = load(filename)
corner = (len(src)-1, len(src[0])-1)
length = 0
for j in range(0, len(src)):
for i in range(0, len(src[0])):
if not (src[j][i] == c): continue
l = 1
found = True
for x in range(i+1, len(src[0])):
if (src[j][x] == c):
l+=1
else:
break
if (l>length):
for y in range(j+1, j+l):
for x in range(i, i+l):
if (src[y][x] != c):
found = False
break
if not found: break
if (found and l>length):
corner = (i,j)
length = l
return (length, corner)
def quadrato(filename, c):
'''Prende in input il percoso file di una immaginee una tupla che rappresenta
un colore, restituisce la dimensione del quadrato pieno più grande
e la posizione (x,y) che corrisponde a dove inizia il quadrato'''
immagine = immagini.load(filename) #lista di liste che contiene l'immagine
h = len(immagine)
l = len(immagine[0])
mask = []
for i in range(h):
row = []
for j in range(l):
row += [1]
mask += [row]
a = 0
d = {} #dizionario vuoto
for i in range(h): #per ogni riga
for j in range(l): #per ogni colonna
if immagine[i][j] == c and mask[i][
j] == 1: #se il pixel (i,j) == colore e il pixel non è stato mascherato
a = quad(
immagine, j, i, c, l, h,
mask) #chiama la funzione quad e metti il risultato in a
if not a in d: #se a non è nel dizionario
d[a] = j, i #assegno alla chiave a i valori j,i
massimo = max(
d) #calcolo la chiave massima del dizionario (quadrato piu grande)
return massimo, d[
massimo] #restituisco la lunghezza del lato e le coordinate associate all chiave
def ricolora(fname, lista, fnameout):
img=load(fname)
risult=[]
for x in lista:
ap=singolo(img,x[0],x[1],x[2],x[3])
risult.append(ap)
save(img,fnameout)
return risult
def cammino(fname, fname1):
img = load(fname)
rosso = (255, 0, 0)
verde = (0, 255, 0)
blu = (0, 0, 255)
bianco = (255, 255, 255)
nero = (0, 0, 0)
flag = 0
x = 0
y = 0
listapassi = []
while flag != 1:
des = 0
while des != 1:
if intorno(img, x, y):
quadrato(img, x, y, 40, 40, blu)
flag = 1
if destra(img, x, y):
quadrato(img, x, y, 40, 40, verde)
x += 40
listapassi.append('0')
else:
des = 1
bas = 0
while bas != 1:
if intorno(img, x, y):
quadrato(img, x, y, 40, 40, blu)
flag = 1
if basso(img, x, y):
quadrato(img, x, y, 40, 40, verde)
y += 40
listapassi.append('1')
else:
bas = 1
sin = 0
while sin != 1:
if intorno(img, x, y):
quadrato(img, x, y, 40, 40, blu)
flag = 1
if sinistra(img, x, y):
quadrato(img, x, y, 40, 40, verde)
x -= 40
listapassi.append('2')
else:
sin = 1
alt = 0
while alt != 1:
if intorno(img, x, y):
quadrato(img, x, y, 40, 40, blu)
flag = 1
if alto(img, x, y):
quadrato(img, x, y, 40, 40, verde)
y -= 40
listapassi.append('3')
else:
alt = 1
save(img, fname1)
return ''.join(listapassi)
def ricolora(fname, lista, fnameout):
img = load(fname)
retval = []
retval = list(map(lambda element: apply_fill(img, element), lista))
save(img, fnameout)
return retval
def cammino(fname, fname1):
prova = load(fname)
prova = cor(prova, 40, (255,0,0))
quad = '0'
x = 40
y = 40
quadra(prova, x,y,verde)
while set(quad[-4:]) != set('bsad'):
while (quad[-1] == '0' or quad[-1] == 'd' ) and prova[y][x + 40] == bianco or prova[y][x + 40] == nero:
x += 40
quadra(prova, x, y , verde)
quad += '0'
else:
quad += 'b'
while (quad[-1] == '1' or quad[-1] == 'b') and prova[y + 40][x] == bianco or prova[y + 40][x] == nero:
y += 40
quadra(prova, x, y , verde)
quad += '1'
else:
quad += 's'
while (quad[-1] == '2' or quad[-1] == 's') and prova[y][x - 40] == bianco or prova[y][x - 40] == nero:
x -= 40
quadra(prova, x, y , verde)
quad += '2'
else:
quad += 'a'
while (quad[-1] == '3' or quad[-1] == 'a') and prova[y - 40][x] == bianco or prova[y - 40][x] == nero:
y -= 40
quadra(prova, x, y , verde)
quad += '3'
else:
quad += 'd'
else:
quadra(prova, x, y, blu)
quad = quad.replace('d','')
quad = quad.replace('a','')
quad = quad.replace('b','')
quad = quad.replace('s','')
prova = senza(prova)
save(prova, fname1)
return quad[1:]
def prova1(filename, c):
A = immagini.load(filename)
righe = len(A)
colonne = len(A[0])
S = set()
for i in range(righe):
for j in range(colonne):
if A[i][j] == c:
S.add((i, j))
return S
def cammino(fname, fname1):
'''Colora di verde le celle della scacchiera dove passa il robottino,
colora di blu la cella dove si ferma'''
rosso = (255, 0, 0)
verde = (0, 255, 0)
blu = (0, 0, 255)
scacchiera = immagini.load(fname)
x = 0
y = 0
passi = 0
codPassi = ''
lenColonne = len(scacchiera[0])
lenRighe = len(scacchiera)
while True:
#Vai a destra
while y + 40 < lenColonne and scacchiera[x][
y + 40] != rosso and scacchiera[x][y + 40] != verde:
passi += 1
colora(scacchiera, x, y, verde)
y += 40
codPassi += '0'
#Vai verso il basso
while x + 40 < lenRighe and scacchiera[
x + 40][y] != rosso and scacchiera[x + 40][y] != verde:
passi += 1
colora(scacchiera, x, y, verde)
x += 40
codPassi += '1'
#Vai a sinistra
while y - 40 >= 0 and scacchiera[x][y - 40] != rosso and scacchiera[x][
y - 40] != verde:
passi += 1
colora(scacchiera, x, y, verde)
y -= 40
codPassi += '2'
#Vai verso l'alto
while x - 40 >= 0 and scacchiera[x - 40][y] != rosso and scacchiera[
x - 40][y] != verde:
passi += 1
colora(scacchiera, x, y, verde)
x -= 40
codPassi += '3'
if passi == 0:
break
passi = 0
colora(scacchiera, x, y, blu)
immagini.save(scacchiera, fname1)
return codPassi
def quadrato(filename, C):
img = load(filename)
L_inv = estrattore_LInversa(img)
A_dimensione = 1
for y in range(len(img)):
for x in range(len(img[0])):
if img[y][x] == C:
while essere_quadrato(y, x, L_inv, A_dimensione, C, img):
primo_pixel = (x, y)
A_dimensione += 1
return A_dimensione - 1, primo_pixel
def quadrato(filename, c):
'''Prende in input un immagine ed un colore e ritorna il quadrato più grande di quel colore presente nell'immagine'''
img, w, h = genMatrix(load(filename), c)
maxVal, coords = 0, ()
for y in range(h-2, -1, -1):
for x in range(w-2, -1, -1):
if img[y][x][0]:
n = min(img[y][x+1][1], img[y+1][x+1][1], img[y+1][x][1]) + 1
img[y][x][1] = n
if n >= maxVal:
maxVal, coords = n, (x, y)
return (maxVal, coords)
def ricolora(fname, lista, fnameout):
img=load(fname)
i=0
lista_finale=[]
while i<len(lista):
ambush=0
pembush=0
y=lista[i][1]
c1=lista[i][2]
x=lista[i][0]
c2=lista[i][3]
ciccio=[(x,y)]
pem=[]
for eddai in ciccio:
x,y=eddai
if inside(img,x+1,y)==True and img[y][x+1]==img[y][x]:
if(x+1,y) not in ciccio:
ciccio+=((x+1,y))
if inside(img,x-1,y)==True and img[y][x-1]==img[y][x]:
if(x-1,y) not in ciccio:
ciccio+=((x-1,y))
if inside(img,x,y+1)==True and img[y+1][x]==img[y][x]:
if(x,y+1) not in ciccio:
ciccio+=((x,y+1))
if inside(img,x,y-1)==True and img[y-1][x]==img[y][x]:
if(x,y-1) not in ciccio:
ciccio+=((x,y-1))
for lardo in ciccio:
x,y=lardo
img[y][x]=c1
ambush+=1
if connessi(img,x,y,ciccio)!=4:
pem+=((x,y))
for pixel in pembush:
a,b=pixel
img[b][a]=c2
pembush+=1
lista_finale+=(ambush,pembush)
i+=1
save(img,fnameout)
return lista_finale
def cammino(fname, fname1):
f = immagini.load(fname)
out = f
rosso = (255, 0, 0)
verde = (0, 255, 0)
blu = (0, 0, 255)
bianco = (255, 255, 255)
nero = (0, 0, 0)
draw_rect(out, 0, 0, 40, 40, (0, 255, 0))
l = len(f[0])
h = len(f)
xL = 0
yL = 40
back = ''
direct = '0'
end = '0'
controllo = ' '
while True:
if direct == '0':
out, xL, yL, direct, end = check0(out, xL, yL, rosso, verde, blu,
end, l, h)
pass
if direct == '1':
out, xL, yL, direct, end = check1(out, xL, yL, rosso, verde, blu,
end, l, h)
pass
if direct == '2':
out, xL, yL, direct, end = check2(out, xL, yL, rosso, verde, blu,
end, l, h)
pass
if direct == '3':
out, xL, yL, direct, end = check3(out, xL, yL, rosso, verde, blu,
end, l, h)
pass
if direct == '':
immagini.save(out, fname1)
return end
def cammino(fname, fname1):
'''Implementare qui la funzione'''
passaggi = []
img = load(fname)
lato = 40
# effettuo la prima mossa verso destra!
draw_cella(img, 0, 0, lato, lato, VERDE)
muovi(img, 40, 0, 0, 0, lato, passaggi)
# salvo l'immagine
save(img, fname1)
return "".join(passaggi)
def quadrato(filename, c):
image = load(filename)
mat = convert_to_matrix(image, c)
width = len(mat[0])
heigth = len(image)
i = 0
found = [0, 0, 0]
while i < heigth:
j = 0
while j < width:
if mat[i][j]:
s = grande(mat, i, j, found[0])
found = maggiore(found, [s, i, j])
j += 1
i += 1
return (found[0], (found[2], found[1]))
def ricolora(fname, lista, fnameout):
global h, w, img, bufferino, ins_area, ins_perimetro, colore
img = load(fname)
h = len(img)
w = len(img[0])
risultato = []
for task in lista:
x, y, c1, c2 = task[0], task[1], task[2], task[3]
ins_area = set()
ins_perimetro = set()
colore = img[y][x]
bufferino = {(x, y)}
p_connessi(x, y) #senza = perche non ritorna niente
colora_p(c1, c2)
risultato.append((len(ins_area), len(ins_perimetro)))
save(img, fnameout)
return risultato
def cammino(fname, fname1):
f = load(fname)
m = matrice(f, 15)
pat = matrice(f, 15)
posi = (0, 0)
dire = (0, 1)
p = ""
pat[0][0] = 2
c=int(pat[posi[0]][max(0,min(posi[1]-1,14))]==1)+\
int(pat[max(0,min(posi[0]-1,14))][posi[1]]==1)+\
int(pat[max(0,min(posi[0]+1,14))][posi[1]]==1)+\
int(pat[posi[0]][max(0,min(posi[1]+1,14))]==1)
while c > 0:
newposi = (max(0, min(posi[0] + dire[0],
14)), max(0, min(posi[1] + dire[1], 14)))
nextc = m[newposi[0]][newposi[1]]
patc = pat[newposi[0]][newposi[1]]
if nextc * patc == 1:
pat[newposi[0]][newposi[1]] = 2
posi = (posi[0] + dire[0], posi[1] + dire[1])
if dire == (1, 0):
p += '1'
elif dire == (0, 1):
p += '0'
elif dire == (-1, 0):
p += '3'
else:
p += '2'
else:
if dire == (1, 0):
dire = (0, -1)
elif dire == (0, 1):
dire = (1, 0)
elif dire == (0, -1):
dire = (-1, 0)
else:
dire = (0, 1)
if int(pat[posi[0]][max(0,min(posi[1]-1,14))]==1)+\
int(pat[max(0,min(posi[0]-1,14))][posi[1]]==1)+\
int(pat[max(0,min(posi[0]+1,14))][posi[1]]==1)+\
int(pat[posi[0]][max(0,min(posi[1]+1,14))]==1)<=0:
break
f = color(f, pat, posi)
save(f, fname1)
return p
def ricolora(fname, lista, fnameout):
ris = []
image = load(fname)
for q in lista:
mat = [[VUOTO for i in range(0, len(image[0]))]
for j in range(0, len(image))]
r = q[0]
c = q[1]
orig = image[c][r]
mat[r][c] = DA_ESAMINARE
count = segna_connessi(image, mat, orig)
while count > 0:
count = segna_connessi(image, mat, orig)
apply_changes(image, mat, q)
area, perim = conta(mat, COLORE), conta(mat, PERIMETRO)
ris.append((area, perim))
save(image, fnameout)
return ris
def es42(fImageIn, fcolori, fImageOut):
img = immagini.load(fImageIn)
h = len(img)
w = len(img[0])
conteggio = 0
palette = {}
with open(fcolori) as f:
for line in f:
r, g, b, R, G, B = map(int, line.split())
palette[(r, g, b)] = R, G, B
for y in range(h):
for x in range(w):
c = img[y][x]
if c in palette:
img[y][x] = palette[c]
conteggio += 1
immagini.save(img, fImageOut)
return conteggio
