def encolher(imagem,factor_x, factor_y):
"""
Encolhe a imagem de acordo com os factores.
Estes devem ser inteiros.
"""
largura = imagem.getWidth()
altura = imagem.getHeight()
nova_largura = largura // factor_x
nova_altura = altura // factor_y
nova_imagem = cImage.EmptyImage(nova_largura,nova_altura)
for coluna in range(nova_largura):
for linha in range(nova_altura):
pixel = imagem.getPixel(coluna * factor_x, linha * factor_y)
nova_imagem.setPixel(coluna,linha, pixel)
return nova_imagem
def espelho_h_s(imagem_fich):
"""Faz o espelho horizontal de uma imagem.
Usa a parte superior."""
imagem = cImage.FileImage(imagem_fich)
largura = imagem.getWidth()
altura = imagem.getHeight()
janela = cImage.ImageWin('Espelho Vertical Superior', 2*largura,altura)
imagem.draw(janela)
nova_imagem = cImage.EmptyImage(largura,altura)
for coluna in range(largura):
for linha in range(altura//2):
pixel = imagem.getPixel(coluna, linha)
nova_imagem.setPixel(coluna,linha,pixel)
nova_imagem.setPixel(coluna,altura - linha - 1,pixel)
nova_imagem.setPosition(largura + 1, 0)
nova_imagem.draw(janela)
janela.exitOnClick()
def negativo_imagem(imagem_ficheiro):
imagem_velha = cImage.FileImage(imagem_ficheiro)
largura = imagem_velha.getWidth()
altura = imagem_velha.getHeight()
janela = cImage.ImageWin('Negativos', 2 * largura, altura)
imagem_velha.draw(janela)
imagem_nova = cImage.EmptyImage(largura, altura)
for coluna in range(largura):
for linha in range(altura):
pixel_original = imagem_velha.getPixel(coluna, linha)
novo_pixel = negativo_pixel(pixel_original)
imagem_nova.setPixel(coluna, linha, novo_pixel)
imagem_nova.setPosition(largura + 1, 0)
imagem_nova.draw(janela)
janela.exitOnClick()
def removeGreen(image):
myimagewindow = cImage.ImageWin("Image Processing",600,200)
oldimage = cImage.FileImage(image)
oldimage.draw(myimagewindow)
width = oldimage.getWidth()
height = oldimage.getHeight()
newim = cImage.EmptyImage(width,height)
for row in range(height):
for col in range(width):
originalPixel = oldimage.getPixel(col,row)
newPixel = noGreen(originalPixel)
newim.setPixel(col,row,newPixel)
newim.setPosition(width+1,0)
newim.draw(myimagewindow)
myimagewindow.exitOnClick()
def altera(imagem, factor_x, factor_y):
"""Altera a imagem de acordo com os factores.
Estes devem ser inteiros.
"""
largura = imagem.getWidth()
altura = imagem.getHeight()
nova_imagem = cImage.EmptyImage(factor_x * largura, factor_y * altura)
for coluna in range(largura):
for linha in range(altura):
pixel = imagem.getPixel(coluna, linha)
for i_x in range(factor_x):
for i_y in range(factor_y):
nova_imagem.setPixel(factor_x * coluna + i_x,
factor_y * linha + i_y, pixel)
return nova_imagem
def main():
win = image.ImageWin()
img = image.Image("spacetacocat.gif")
w = img.getWidth()
h = img.getHeight()
newImage = image.EmptyImage(w,h)
for row in range(h):
for col in range(w):
p = img.getPixel(col,row)
newImage.setPixel(col,row,p)
newImage.draw(win)
win.exitonclick()
def espelho_h_d(imagem_fich):
"""Faz o espelho orizontal de uma imagem.
Usa a parte direita."""
imagem = cImage.FileImage(imagem_fich)
largura = imagem.getWidth()
altura = imagem.getHeight()
janela = cImage.ImageWin('Espelho Horizontal Direita', 2*largura,altura)
imagem.draw(janela)
nova_imagem = cImage.EmptyImage(largura,altura)
for coluna in range(largura/2, largura):
for linha in range(altura):
pixel = imagem.getPixel(coluna, linha)
nova_imagem.setPixel(coluna,linha,pixel)
nova_imagem.setPixel(largura - coluna - 1,linha,pixel)
nova_imagem.setPosition(largura + 1, 0)
nova_imagem.draw(janela)
janela.exitOnClick()
def noise_reduction(median):
img = image.Image(input("Enter image name, including file extension: "))
newimg = image.EmptyImage(img.getWidth(), img.getHeight())
for x in range(1,
img.getWidth() -
1): # ignore the edge pixels for simplicity
for y in range(1,
img.getHeight() -
1): # ignore the edge pixels for simplicity
p0 = img.getPixel(x - 1, y - 1)
p1 = img.getPixel(x - 1, y)
p2 = img.getPixel(x - 1, y + 1)
p3 = img.getPixel(x, y - 1)
p4 = img.getPixel(x, y)
p5 = img.getPixel(x, y + 1)
p6 = img.getPixel(x + 1, y - 1)
p7 = img.getPixel(x + 1, y)
p8 = img.getPixel(x + 1, y + 1)
r = int(
median([
p0[0], p1[0], p2[0], p3[0], p4[0], p5[0], p6[0], p7[0],
p8[0]
]))
g = int(
median([
p0[1], p1[1], p2[1], p3[1], p4[1], p5[1], p6[1], p7[1],
p8[1]
]))
b = int(
median([
p0[2], p1[2], p2[2], p3[2], p4[2], p5[2], p6[2], p7[2],
p8[2]
]))
newPixel = image.Pixel(r, g, b)
newimg.setPixel(x, y, newPixel)
win = image.ImageWin()
newimg.draw(win)
win.exitonclick()
def makeRectangle(width, height, desiredPixel):
"""
Create a rectangular image of specified size and color
Arguments:
width: desired width, in pixels, of rectangle
height: desired height, in pixels, of rectangle
desiredPixel: color for each pixel in the rectangle
Returns:
a rectangle with the specified properties
"""
resultImage = cImage.EmptyImage(width + 100, height + 100)
for col in range(height):
for row in range(width):
resultImage.setPixel(row, col, desiredPixel)
return resultImage
def imagem_cinzentos(imagem_fich):
""" Transforma para escala de cinzentos a imagem."""
imagem = cImage.FileImage(imagem_fich)
largura = imagem.getWidth()
altura = imagem.getHeight()
janela = cImage.ImageWin('Escala de cinzentos', 2 * largura, altura)
imagem.draw(janela)
nova_imagem = cImage.EmptyImage(largura, altura)
for coluna in range(largura):
for linha in range(altura):
pixel = imagem.getPixel(coluna, linha)
novo_pixel = pixel_cinzento(pixel)
nova_imagem.setPixel(coluna, linha, novo_pixel)
nova_imagem.setPosition(largura + 1, 0)
nova_imagem.draw(janela)
janela.exitOnClick()
def reforca_vermelho(imagem_fich):
""" Intensifica vermelho."""
imagem = cImage.FileImage(imagem_fich)
largura = imagem.getWidth()
altura = imagem.getHeight()
janela = cImage.ImageWin('Sem Vermelho', 2 * largura, altura)
imagem.draw(janela)
nova_imagem = cImage.EmptyImage(largura, altura)
for coluna in range(largura):
for linha in range(altura):
pixel = imagem.getPixel(coluna, linha)
novo_pixel = cImage.Pixel(255, pixel.getGreen(), pixel.getBlue())
nova_imagem.setPixel(coluna, linha, novo_pixel)
nova_imagem.setPosition(largura + 1, 0)
nova_imagem.draw(janela)
janela.exitOnClick()
def double(self, draw=0):
"Double the size of the image"
# The canvas size gets annoyingly big so by default we avoid drawing here.
self.draw = draw
# We overwrite self.newimg because we need double the canvas size.
self.newimg = image.EmptyImage(self.width * 2, self.height * 2)
# In case we do decide to draw, self.win needs double canvas, too.
if self.draw:
self.win = image.ImageWin(self.img_file, self.width * 2,
self.height * 2)
for y in range(self.height):
for x in range(self.width):
p = self.oldimg.getPixel(x, y)
self.newimg.setPixel(2 * x, 2 * y, p)
self.newimg.setPixel(2 * x + 1, 2 * y, p)
self.newimg.setPixel(2 * x, 2 * y + 1, p)
self.newimg.setPixel(2 * x + 1, 2 * y + 1, p)
self.write("_double", 0)
def cria_imagem_simples(largura, altura):
pixel_vermelho = cImage.Pixel(255,0,0)
pixel_azul = cImage.Pixel(0,0,255)
imagem = cImage.EmptyImage(largura,altura)
for coluna in range(largura):
for linha in range(altura):
if coluna % 10 == 0:
imagem.setPixel(coluna,linha, pixel_vermelho)
else:
imagem.setPixel(coluna,linha, pixel_azul)
imagem.setPosition(largura,altura)
janela = cImage.ImageWin('Imagem Simples', 2*largura,2*altura)
janela.setBackground('green')
imagem.draw(janela)
janela.exitOnClick()
def removeRed():
img = image.Image(input("Enter image name, including file extension: "))
newimg = image.EmptyImage(img.getWidth(), img.getHeight())
for x in range(img.getWidth()):
for y in range(img.getHeight()):
p = img.getPixel(x, y)
r = 0
g = p[1]
b = p[2]
newPixel = image.Pixel(r, g, b)
newimg.setPixel(x, y, newPixel)
win = image.ImageWin()
newimg.draw(win)
win.exitonclick()
def nul_change_image():
img = image.Image(input("Enter image name, including file extension: "))
newimg = image.EmptyImage(img.getWidth(), img.getHeight())
for x in range(img.getWidth()):
for y in range(img.getHeight()):
p = img.getPixel(x, y)
r = int(p[0])
g = int(p[1])
b = int(p[2])
newPixel = image.Pixel(r, g, b)
newimg.setPixel(x, y, newPixel)
win = image.ImageWin()
newimg.draw(win)
win.exitonclick()
def convolve_geral(imagem_fich, kernel):
imagem = cImage.FileImage(imagem_fich)
largura = imagem.getWidth()
altura = imagem.getHeight()
janela_antiga = cImage.ImageWin('Original', largura, altura)
mostra_imagem_c(imagem, janela_antiga)
nova_imagem = cImage.EmptyImage(largura, altura)
for linha in range(1, altura - 1):
for coluna in range(1, largura - 1):
r, g, b = convolve_todos(imagem, linha, coluna, kernel)
pixel_cor = cImage.Pixel(r, g, b)
pixel_cinza = pixel_cinzento(pixel_cor)
nova_imagem.setPixel(coluna, linha, pixel_cor)
janela_nova = cImage.ImageWin('Transformada', largura, altura)
mostra_imagem_c(nova_imagem, janela_nova)
janela_antiga.exitOnClick()
janela_nova.exitOnClick()
def sepiaTone():
img = image.Image(input("Enter image name, including file extension: "))
newimg = image.EmptyImage(img.getWidth(), img.getHeight())
for x in range(img.getWidth()):
for y in range(img.getHeight()):
p = img.getPixel(x, y)
newRed = int(p[0] * .393 + p[1] * .769 + p[2] * .189)
newGreen = int(p[0] * .349 + p[1] * .686 + p[2] * .168)
newBlue = int(p[0] * .272 + p[1] * .534 + p[2] * .131)
newPixel = image.Pixel(newRed, newGreen, newBlue)
newimg.setPixel(x, y, newPixel)
win = image.ImageWin()
newimg.draw(win)
win.exitonclick()
def median (im, width, height, param={}) :
import cImage
newImage = cImage.EmptyImage(width,height)
filterWidth = param.get('FilterWidth', 3)
filterHeight = param.get('FilterHeight', 3)
heightBuffer = height - filterHeight
widthBuffer = width - filterWidth
for row in range(height):
for col in range(width):
if col < filterWidth or col > widthBuffer or row < filterHeight or row > heightBuffer:
old_pixel = im.getPixel(col, row)
newImage.setPixel(col, row, old_pixel)
else :
minWidth = col - filterWidth//2
maxWidth = col + filterWidth//2
minHeight = row - filterHeight//2
maxHeight = row + filterHeight//2
rlist = []
glist = []
blist = []
for width in range(minWidth, maxWidth) :
pixel = im.getPixel(width, row)
rlist.append(pixel.getRed())
glist.append(pixel.getGreen())
blist.append(pixel.getBlue())
for height in range(minHeight, maxHeight) :
pixel = im.getPixel(col, height)
rlist.append(pixel.getRed())
glist.append(pixel.getGreen())
blist.append(pixel.getBlue())
rlist = sorted(rlist)
glist = sorted(glist)
blist = sorted(blist)
r = int(sum(rlist[(len(rlist)//2)-1:(len(rlist)//2)+1]))//2
g = int(sum(glist[(len(glist)//2)-1:(len(glist)//2)+1]))//2
b = int(sum(blist[(len(blist)//2)-1:(len(blist)//2)+1]))//2
new_pixel=cImage.Pixel(r, g, b)
newImage.setPixel(col,row,new_pixel)
return newImage
def arco(x, y, raio, amplitude):
"""
Desenha (um arco de circunferência) com centro em (x,y) e raio.
"""
janela = cImage.ImageWin('Janela', 600, 400)
imagem = cImage.EmptyImage(600, 400)
pixel_branco = cImage.Pixel(255, 255, 255)
for coluna in range(600):
for linha in range(400):
imagem.setPixel(coluna, linha, pixel_branco)
#imagem.setPosition(x,y)
pixel = cria_random_pixel()
for angulo in range(amplitude):
cordx = (raio * math.cos((math.pi / float(180)) * angulo)) + x
cordy = (raio * math.sin((math.pi / float(180)) * angulo)) + y
imagem.setPixel(cordx, cordy, pixel)
imagem.draw(janela)
janela.exitOnClick()
def desenha_linha(p_1,p_2):
"""Desenha uma linha entre dois pontos."""
x_1 = p_1[0]
y_1 = p_1[1]
x_2 = p_2[0]
y_2 = p_2[1]
janela = cImage.ImageWin('Linha', 3* abs(x_2 - x_1), 3*abs(y_2 - y_1))
janela.setBackground((0,255,0))
imagem = cImage.EmptyImage(abs(x_2 - x_1),abs(y_2 - y_1))
print(imagem.getWidth(), imagem.getHeight())
pix = cImage.Pixel(255,0,0)
for x in range(0, imagem.getWidth()):
for k in range(0, imagem.getHeight()):
imagem.setPixel(x,k,cImage.Pixel(0,255,0))
y = int(x * ((y_2 - y_1)/(x_2 - x_1)) + y_1 - x_1 * ((y_2 - y_1)/ (x_2 - x_1)))
imagem.setPixel(x,y,pix)
imagem.setPosition(janela.getWidth()//2 - imagem.getWidth()//2,janela.getHeight()//2 - imagem.getHeight()//2)
imagem.draw(janela)
janela.exitOnClick()
def negative():
img = image.Image(input("Enter image name, including file extension: "))
newimg = image.EmptyImage(img.getWidth(), img.getHeight())
for x in range(img.getWidth()):
for y in range(img.getHeight()):
p = img.getPixel(x, y)
r = 255 - p[
0] # using index[0] to access red intensity, instead of newred = 255 - p.getRed()
g = 255 - p[1]
b = 255 - p[2]
newPixel = image.Pixel(r, g, b)
newimg.setPixel(x, y, newPixel)
win = image.ImageWin()
newimg.draw(win)
win.exitonclick()
def noRed(img):
"""Remove all the red values from an image"""
img = image.Image(img)
newimg = image.EmptyImage(img.getWidth(), img.getHeight())
win = image.ImageWin()
for col in range(img.getWidth()):
for row in range(img.getHeight()):
p = img.getPixel(col, row)
noR = 0
g = p.getGreen()
b = p.getBlue()
newp = image.Pixel(noR, g, b)
newimg.setPixel(col, row, newp)
newimg.draw(win)
win.exitonclick()
def makeDiagonal(size, desiredPixel):
"""
Create an image with dimensions (size x size) of a given pixel in the
shape of a diagonal line from the northwest to southeast corners.
Arguments:
size: width and height, in pixels, of image to be generated
desiredPixel: color of diagonal line (background will be black)
Returns:
a square image with the specified properties
"""
# Begin with a square image with all black pixels
resultImage = cImage.EmptyImage(size, size)
# Set pixels along the diagonal
for i in range(size):
resultImage.setPixel(i, i, desiredPixel)
return resultImage
def convolve_geral(imagem_fich, kernel):
""" Convolve imagem a cores dado o kernel. """
imagem = cImage.FileImage(imagem_fich)
largura = imagem.getWidth()
altura = imagem.getHeight()
janela_antiga = cImage.ImageWin('Original', largura, altura)
mostra_imagem_c(imagem, janela_antiga)
nova_imagem = cImage.EmptyImage(largura, altura)
for linha in range(1, altura - 1):
for coluna in range(1, largura - 1):
r, g, b = convolve_cor(imagem, linha, coluna, kernel)
pixel_cor = cImage.Pixel(r, g, b)
# se for em escala de cinzentos incluir e alterar setPixel
#pixel_cinza = pixel_cinzento(pixel_cor)
nova_imagem.setPixel(coluna, linha, pixel_cor)
janela_nova = cImage.ImageWin('Transformada', largura, altura)
mostra_imagem_c(nova_imagem, janela_nova)
janela_antiga.exitOnClick()
janela_nova.exitOnClick()
def smooth():
img = image.Image(input("Enter image name, including file extension: "))
newimg = image.EmptyImage(img.getWidth(), img.getHeight())
for x in range(img.getWidth() - 1):
for y in range(img.getHeight() - 1):
p0 = img.getPixel(x, y)
p1 = img.getPixel(x + 1, y)
newRed = int(((p0.getRed()) + (p1.getRed())) / 2)
newGreen = int(((p0.getGreen()) + (p1.getGreen())) / 2)
newBlue = int(((p0.getBlue()) + (p1.getBlue())) / 2)
newPixel = image.Pixel(newRed, newGreen, newBlue)
newimg.setPixel(x, y, newPixel)
win = image.ImageWin()
newimg.draw(win)
win.exitonclick()
def expcImage(img):
'''
This function will take a cImage object and expand it to be double its original dimensions.
:param img: cImage image object, A x B, png format.
:return: cImage image object, 2A x 2B, png format
'''
oldw = img.getWidth()
oldh = img.getHeight()
newim = image.EmptyImage(oldw * 2, oldh * 2)
for row in range(oldh):
for col in range(oldw):
oldpixel = img.getPixel(col, row)
newim.setPixel(2 * col, 2 * row, oldpixel)
newim.setPixel(2 * col + 1, 2 * row, oldpixel)
newim.setPixel(2 * col, 2 * row + 1, oldpixel)
newim.setPixel(2 * col + 1, 2 * row + 1, oldpixel)
return newim
def preto_branco(imagem_fich, limiar):
""" Transforma para imagem a preto e branco."""
imagem = cImage.FileImage(imagem_fich)
largura = imagem.getWidth()
altura = imagem.getHeight()
nova_imagem = cImage.EmptyImage(largura, altura)
for coluna in range(largura):
for linha in range(altura):
pixel = imagem.getPixel(coluna, linha)
pixel_aux = pixel_cinzento(pixel)
if pixel_aux.getRed() < limiar:
novo_pixel = cImage.Pixel(0, 0, 0)
else:
novo_pixel = cImage.Pixel(255, 255, 255)
nova_imagem.setPixel(coluna, linha, novo_pixel)
return nova_imagem
def black_and_white():
img = image.Image(input("Enter image name, including file extension: "))
newimg = image.EmptyImage(img.getWidth(), img.getHeight())
for x in range(img.getWidth()):
for y in range(img.getHeight()):
p = img.getPixel(x, y)
avg_pixel = int((p[0] + p[1] + p[2]) / 3)
if avg_pixel > 255 / 2:
newPixel = image.Pixel(255, 255, 255)
else:
newPixel = image.Pixel(0, 0, 0)
newimg.setPixel(x, y, newPixel)
win = image.ImageWin()
newimg.draw(win)
win.exitonclick()
def blur(img):
""" Diminuição da pixelização"""
largura = img.getWidth()
altura = img.getHeight()
imagem = img.toList()
nova_imagem = cImage.EmptyImage(largura, altura)
for coluna in range(1, largura - 1):
for linha in range(1, altura - 1):
pixel = img.getPixel(coluna, linha)
# Calcula valores da vizinhança
lista_pix = [
imagem[linha + i_y][coluna + i_x] for i_y in [-1, 0, 1]
for i_x in [-1, 0, 1]
]
# Suaviza
r = sum(get_red(lista_pix)) // 9
g = sum(get_green(lista_pix)) // 9
b = sum(get_blue(lista_pix)) // 9
novo_pixel = cImage.Pixel(r, g, b)
nova_imagem.setPixel(coluna, linha, novo_pixel)
return nova_imagem
def funde(imagem1, imagem2, funcao):
largura_1 = imagem1.getWidth()
altura_1 = imagem1.getHeight()
largura_2 = imagem2.getWidth()
altura_2 = imagem2.getHeight()
largura = min(largura_1, largura_2)
altura = min(altura_1, altura_2)
nova_imagem = cImage.EmptyImage(largura, altura)
for coluna in range(largura):
for linha in range(altura):
pix1 = imagem1.getPixel(coluna, linha)
pix2 = imagem2.getPixel(coluna, linha)
novo_pixel = combina_pixel(pix1, pix2, funcao)
nova_imagem.setPixel(coluna, linha, novo_pixel)
return nova_imagem
