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