UNIVERSIDADE ESTADUAL DE MARINGÁ

CENTRO DE TECNOLOGIA
DEPARTAMENTO DE INFORMÁTICA
PROGRAMA DE PÓS-GRADUAÇÃO EM CIÊNCIA DA COMPUTAÇÃO

Curso: Mestrado em Ciência da Computação

Disciplina: Processamento Digital de Imagens - DIN4064

Professor: Franklin César Flores

Alunos:

RA 903374 – Adauto Santos

RA 904010 – Marcos de Assumpção

Relatório do trabalho número 02:

Implementação de algoritmos para:

a) Rotação de imagens
b) Redimensionamento de imagens
Algoritmo 1: Rotação de imagem

Objetivo:
Dada uma imagem, solicitar ao usuário um grau de rotação (0-360) e aplicá-lo na imagem.

Após o processamento, exibir a imagem em tela.

Desenvolvimento e dificuldades encontradas:

Para desenvolver este trabalho utilizamos a linguagem Python.Para calculo deseno e cosseno
utilizamos a biblioteca “Math”.

Ao girar uma imagem retangular sabemos que seus cantos se deslocam para cima e para baixo,
e para que a imagem inteira seja exibida é preciso aumentar a matriz da imagem resultante ou
reduzir a imagem calculada. Para calculo da dimensão necessária para a imagem de saída
utilizamos o calculo abaixo:

n_largura = int( (altura * abs(sin)) + (largura * abs(cos))) #nova largura

n_altura= int( (altura * abs(cos)) + (largura * abs(sin))) #nova altura

Desta forma não será preciso fazer cortes na imagem. Uma vez criada a matriz destino que
formaria a imagem de saída, varemos todos os pontos dessa matriz e realizamos o
“mapeamento inverso” (pra cada ponto de saída, calculamos qual o ponto na imagem origem
ele deve representar).

Outro problema encontrado foi que ao rotacionar a imagem ela se deslocava em relação ao
centro e conforme o ângulo informado a imagem “fugia” do quadro. Tivemos que fazer um
controle do centro da imagem origem/destino para que ela pudesse ficar centralizada e sem
cortes.
Demonstração
emonstração do experimento:
1 – Tela do Pyzo com o código carregado iniciando a execução,, solicita o ângulo de rotação:

2- Na sequencia o programa exibe a imagem original

3- Ao teclar enter a imagem rotacionada é exibida na sequencia, abaixo rotação a 45 graus:

4- Execução com rotação a 90 graus:

5- Execução com rotação a 275 graus:

Algoritmo 2: Redimensionamento(escala) de imagem

Objetivo:
Dada uma imagem, solicitar um valor percentual para ampliação (>100) ou redução (<100) e
aplicar na imagem de origem e exibi
exibi-la em tela.

Desenvolvimento e dificuldades encontradas:

Para desenvolver este trabalho utilizamos a linguagem Python.

O processo de escala de imagem é relat

relativamente simples.

Demonstração
emonstração do experimento:
1 – Tela do Pyzo com o código carrega
carregado e solicitando no prompt do console o valor da
ampliação.. Valor informado no exemplo: 50

2- Em seguida são exibidas a imagem original e a imagem com a escala informada aplicada:
Repare na área do prompt que exibimos as dimensões da imagem original e da imagem final
(220x220  110x110), pelos valores confirma
confirma-se
se que ocorreu a redução de escala.

3- Executando com escala de 175%

Repare na área do prompt que exibimos as dimensões da imagem original e da imagem final
(220x220  385x385), pelos valores confirma
confirma-se
se que ocorreu a ampliação de escala.

Anexo 1 – código Fonte Rotação:

"""
Universidade Estadual de Maringa
Departamento de Informática
Trabalho de Processamento Digital de Imagens
Prof. Franklin Flores
Alunos de Mestrado:
Adauto Santos RA: 903374
Marcos de Assumpção RA: 904010

Objetivo: Dada uma imagem, obter um valor de angulo para rotacionar a image
imagem original
"""
import cv2
importnumpy as np
import math
frommatplotlib import pyplot as plt

### Carregar a imagem original

nomeArquivo = "C:\\Temp\\lena.png"
imgOriginal = cv2.imread(nomeArquivo,1)
imgOriginal = cv2.cvtColor(imgOriginal,cv2.COLOR_BGR2RGB)

largura = imgOriginal.shape[0] #largura da imagem

altura = imgOriginal.shape[1] #altura da imagem

###aguarda o usuario digitar um valor do grau de rotacao:

angulo = int(input('informe um valor para rotacionar a imagem(0-360):'))

angulo = math.radians(float(angulo))
sin = math.sin(angulo)
cos = math.cos(angulo)
centroX = 0.5 * (float(largura) - 1.0)
centroY = 0.5 * (float(altura) - 1.0)

### calculamos a nova largura da imagem final para poder encaixar a imagem inclinada
n_largura = ( (altura * abs(sin)) + (largura * abs(cos))) #nova largura
n_altura = ( (altura * abs(cos)) + (largura * abs(sin))) #nova altura

### Inicializa nova figura

imgFinal = np.zeros((n_largura,n_altura,3),np.uint8)
n_centroX = 0.5 * (float(n_largura) - 1.0) #novo centro x
n_centroY = 0.5 * (float(n_altura) - 1.0) #novo centro Y

### Mapeamento inverso: Varre cada ponto da imagem final, puscando na imagem origem o
ponto a mapear
forcoluna in range(n_largura):
for linha in range(n_altura):
# Formula página 57, adicionando o desclocamento dos centros
#x= v*cos(ang) - w* sen(ang)
#y= v*sen(ang) + w* cos(ang)
colOrigem = int((float(coluna) - n_centroX) * cos - (float(linha) - n_centroY) * sin +
centroX)
linOrigem = int((float(coluna) - n_centroX) * sin + (float(linha) - n_centroY) * cos +
centroY)
### o mapeamento inverso encontrou uma coordenada dentro da figura original,
entaotransfere ele
if (colOrigem>= 0) and (colOrigem< largura) and (linOrigem>= 0) and (linOrigem< altura):
imgFinal[coluna][linha] = imgOriginal[colOrigem][linOrigem]

# imprime as duas imagens em tela

cv2.imshow('Imagem RGB original',imgOriginal)
cv2.waitKey(0)
cv2.imshow('Imagem Final',imgFinal)
cv2.waitKey(0)
cv2.destroyAllWindows()
Anexo 2 – código Fonte redimensionamento/Escala:
"""
Universidade Estadual de Maringa
Departamento de Informática
Trabalho de Processamento Digital de Imagens
Prof. Franklin Cesar Flores
Alunos de Mestrado:
Adauto Santos RA: 903374
Marcos de Assumpção RA: 904010

Objetivo: Dada uma imagem, obter um valor % de escala para ampliar ou reduzir a imagem
original
"""

import cv2
importnumpy as np

def novasMedidas(p_percent):
#rotina que recalcula as novas medidas da nova imagem que sera gerada.
#p_percent e o percentual informado pelo usuario<100 diminui>100 aumenta
largura = int(imgOriginal.shape[0]*p_percent/100)
altura = int(imgOriginal.shape[1]*p_percent/100)
return(largura,altura)

fileName = "C:\\Temp\\lena.png"
imgOriginal = cv2.imread(fileName,1)

#aguarda o usuario digitar um valor do percentual para ampliar ou reduzir:

percentual = int(input('informe um valor >100 para ampliar <100 para reduzir:'))

#chama a funcao que calcula o tamanho final da nova imagem

(novaLarg, novaAlt) = novasMedidas(percentual)
#inicializa nova imagem zom zeros
imgFinal=np.zeros((novaLarg,novaAlt,3),np.uint8)

#Escala por mapeamento inverso, p/cada pto da img destino pegamos na origem o pto a ser
representado
forcolunaDestino in range(novaLarg):
forlinhaDestino in range(novaAlt):
colunaOrigem = colunaDestino * imgOriginal.shape[0] // novaLarg
linhaOrigem = linhaDestino * imgOriginal.shape[1] // novaAlt
imgFinal[colunaDestino][linhaDestino] = imgOriginal[colunaOrigem][linhaOrigem]
#imgFinal.set(colunaDestino, linhaDestino, imgOriginal.get(colunaOrigem,
linhaOrigem))

print("Tamanho original:",imgOriginal.shape[0],"x",imgOriginal.shape[1])
print("Tamanho Final:",imgFinal.shape[0],"x",imgFinal.shape[1])

#Exibe em duas janelas a imagem original e final:

cv2.namedWindow('Imagem Original',cv2.WINDOW_NORMAL)
cv2.resizeWindow('Imagem Original', imgOriginal.shape[0],imgOriginal.shape[1])
cv2.imshow('Imagem Original',imgOriginal)
#cv2.waitKey(0)
cv2.namedWindow('Imagem Final',cv2.WINDOW_NORMAL)
cv2.resizeWindow('Imagem Final', novaLarg,novaAlt)
cv2.imshow('Imagem Final',imgFinal)
cv2.waitKey(0)
cv2.destroyAllWindows()