def get_cor_face(self, face, ponto_intercecao, direcao_olho):
soma_cores = CorRGB(0.0, 0.0, 0.0)
for r in range(len(lista_luzes)):
luz_momentanea = lista_luzes[r] #luz
recta1 = Recta(ponto_intercecao, luz_momentanea.posicao)
direcao_luz = (luz_momentanea.posicao - ponto_intercecao).versor()
#os pontos
ponto1 = face.ponto1
ponto2 = face.ponto2
ponto3 = face.ponto3
#os vectores
vector1 = ponto2 - ponto1
vector2 = ponto3 - ponto1
#o vector normal
normal = vector1.externo(vector2).versor()
interseccao_face = ray_tracer.get_face_intercetada_mais_proxima(
recta1)[0]
# Analisa se a recta interseta alguma face
# se não intersetar vai obter a cor Phong
if (interseccao_face == False):
sombra = False
cor = face.cor_phong.get_cor_rgb(luz_momentanea, direcao_luz,
normal, direcao_olho, sombra)
soma_cores = soma_cores.soma(cor)
# caso intersete obter a cor Phong em sombra
else:
sombra = True
cor = face.cor_phong.get_cor_rgb(luz_momentanea, direcao_luz,
normal, direcao_olho, sombra)
soma_cores = soma_cores.soma(cor)
return (soma_cores)
def __init__(self, numero_linhas, numero_colunas):
#constructor, define os atributos
#Define a imagem com o numero de linhas e o numero de colunas
self.numero_linhas = numero_linhas #atributo de um objecto que tem o
#mesmo nome da variavel local
self.numero_colunas = numero_colunas
self.linhas = []
#cria linhas com pixeis
for l in range(numero_linhas):
linha = []
for c in range(numero_colunas):
pixel = CorRGB(0.0, 0.0, 0.0)
linha.append(pixel)
self.linhas.append(linha)
# testes
if __name__ == "__main__":
# teste ao construtor
imagem1 = Imagem(5, 5)
# teste a __str__
imagem2 = Imagem(5, 5)
print(imagem2)
print(" ")
# teste a set_cor
imagem3 = Imagem(5, 5)
branco = CorRGB(1.0, 1.0, 1.0)
imagem3.set_cor(3, 3, branco)
print(imagem3)
print(" ")
# testes a get_cor
imagem4 = Imagem(5, 5)
branco = CorRGB(1.0, 1.0, 1.0)
imagem4.set_cor(3, 3, branco)
print(imagem4.get_cor(3, 3))
print(imagem4.get_cor(5, 5))
print(" ")
# teste a guardar_como_ppm
imagem5 = Imagem(3, 5)
red = CorRGB(1.0, 0.0, 0.0)
def get_intensidade_ambiente(self):
return (self.intensidade_ambiente)
def get_intensidade_difusa(self):
return (self.intensidade_difusa)
def get_intensidade_especular(self):
return (self.intensidade_especular)
# testes
if __name__ == "__main__":
# teste ao construtor
posicao = Ponto3D(1.0, 2.0, 3.0)
i_ambiente = CorRGB(0.1, 0.2, 0.3)
i_difusa = CorRGB(0.4, 0.5, 0.6)
i_especular = CorRGB(0.7, 0.8, 0.9)
luz = Luz(posicao, i_ambiente, i_difusa, i_especular)
# teste a __str__
print(luz)
print(" ")
# teste a get_posicao
print(luz.get_posicao())
print(" ")
# teste a get_intensidade_ambiente
print(luz.get_intensidade_ambiente())
print(" ")
r = direcao_luz * (-1.0) + normal * (2.0 * l_interno_n)
cor_especular = self.k_especular * luz.intensidade_especular * (
(direcao_olho.interno(r))**self.brilho)
resultado = cor_ambiente + cor_difusa + cor_especular
return (resultado)
# testes
if __name__ == "__main__":
# teste ao construtor
material_k_ambiente = CorRGB(0.0, 0.0, 0.1)
material_k_difusa = CorRGB(0.0, 0.0, 0.9)
material_k_especular = CorRGB(1.0, 1.0, 1.0)
material_brilho = 100.0
material_cor = CorPhong(material_k_ambiente, material_k_difusa,
material_k_especular, material_brilho)
# teste a __str__
print(material_cor)
# teste a get_cor_rgb
luz_posicao = Ponto3D(1.0, 0.0, 1.0)
luz_intensidade_ambiente = CorRGB(1.0, 1.0, 1.0)
luz_intensidade_difusa = CorRGB(1.0, 1.0, 1.0)
luz_intensidade_especular = CorRGB(1.0, 1.0, 1.0)
luz = Luz(luz_posicao, luz_intensidade_ambiente, luz_intensidade_difusa,
# vista pelo raio de visão definido pela recta criada
for c in range(colunas):
posicao = camara.posicao
ponto = camara.get_pixel_global(l, c)
recta = Recta(posicao, ponto)
cor = ray_tracer.get_cor_vista_por_raio(recta)
imagem.set_cor(l, c, cor)
return (imagem)
# testes
if __name__ == "__main__":
# teste ao construtor
# teste ao construtor - cor da face
verde = CorRGB(0.0, 0.3, 0.0)
brilho = 100.0
cor = CorPhong(verde, verde, verde, brilho)
# teste ao construtor - face
p1 = Ponto3D(0.0, 0.0, 0.0)
p2 = Ponto3D(1.0, 0.0, 0.0)
p3 = Ponto3D(0.0, 1.0, 0.0)
face = FaceTriangular(p1, p2, p3, cor)
lista_faces = [face]
# teste ao construtor - luz
branco = CorRGB(1.0, 1.0, 1.0)
luz_posicao = Ponto3D(1.0, 0.0, 2.0)
luz = Luz(luz_posicao, branco, branco, branco)
lista_luzes = [luz]
"""Retorna uma string que representa a face triangular."""
return("FaceTriangular(" + super().__str__() + ", " \
+ str(self.cor_phong) + ")")
def get_cor_phong(self):
"""Retorna a cor Phong da face triangular."""
return (self.cor_phong)
# testes
if __name__ == "__main__":
# teste ao construtor
a = Ponto3D(0.0, 0.0, 0.0)
b = Ponto3D(1.0, 0.0, 0.0)
c = Ponto3D(0.0, 1.0, 0.0)
k_ambiente = CorRGB(0.0, 0.0, 0.1)
k_difusa = CorRGB(0.0, 0.0, 0.75)
k_especular = CorRGB(1.0, 1.0, 1.0)
brilho = 100.0
cor = CorPhong(k_ambiente, k_difusa, k_especular, brilho)
face1 = FaceTriangular(a, b, c, cor)
print("Até aqui não foram lançadas exceções.")
# teste à exceção ErroPontosColineares
try:
face2 = FaceTriangular(a, a, c, cor)
except ErroPontosColineares:
print(
"Ao tentar definir-se a face face2 = FaceTriangular(a, a, c, cor)")
print("foi lançada a exceção ErroPontosColineares.")
print("É o comportamento herdado da classe Plano.")
print(" ")