def get_pixel_local(self, linha, coluna):
"""Retorna o Ponto3D na linha e coluna do plano de projeção
especificados pelos argumentos, no sistema de coordenadas
local da câmara.
"""
pixel_x = self.canto_superior_esquerdo_x \
+ (coluna - 1) * self.incremento_horizontal
pixel_y = self.canto_superior_esquerdo_y \
- (linha - 1) * self.incremento_vertical
pixel_z = self.canto_superior_esquerdo_z
return Ponto3D(pixel_x, pixel_y, pixel_z)
def local_para_global(self, ponto):
"""Converte o Ponto3D ponto do sistema de coordendas da câmara
para o sistema de coordenadas global.
"""
local_x = ponto.get_x()
local_y = ponto.get_y()
local_z = ponto.get_z()
p = Matriz(4, 1)
p.set_entrada(1, 1, local_x)
p.set_entrada(2, 1, local_y)
p.set_entrada(3, 1, local_z)
p.set_entrada(4, 1, 1.0) # porque é um ponto
p_transformado = self.matriz * p
global_x = p_transformado.get_entrada(1, 1)
global_y = p_transformado.get_entrada(2, 1)
global_z = p_transformado.get_entrada(3, 1)
return Ponto3D(global_x, global_y, global_z)
or beta > 1.0 \
or lamb_da < 0.0 \
or lamb_da > 1.0 \
or alfa < 0.0 \
or alfa > 1.0:
return [False, None, None]
else:
return [True, ponto_intercecao, t]
# testes
if __name__ == "__main__":
# teste ao construtor
a = Ponto3D(0.0, 0.0, 0.0)
b = Ponto3D(2.0, 0.0, 0.0)
c = Ponto3D(0.0, 2.0, 0.0)
plano1 = Plano(a, b, c)
print("Até aqui não foram lançadas exceções.")
# teste a TOLERANCIA_ZERO
print("TOLERANCIA_ZERO = " + str(TOLERANCIA_ZERO))
# teste à exceção ErroPontosColineares
try:
plano2 = Plano(a, b, b)
except ErroPontosColineares:
print("Ao tentar definir-se o plano plano2 = Plano(a, b, b)")
print("foi lançada a exceção ErroPontosColineares.")
print("A execução foi interrompida. plano2 não ficou definido.")
# teste a __str__
especificados pelos argumentos, no sistema de coordenadas
global onde a câmara está inserida.
"""
pixel_local = self.get_pixel_local(linha, coluna)
pixel_global = self.local_para_global(pixel_local)
return pixel_global
# testes
if __name__ == "__main__":
# teste ao construtor
posicao = Ponto3D(0.0, 0.0, 3.0)
olhar_para = Ponto3D(0.0, 0.0, 0.0)
vertical = Vetor3D(0.0, 1.0, 0.0)
distancia_olho_plano_projecao = 2.0
largura_retangulo_projecao = 2.0
altura_retangulo_projecao = 2.0
resolucao_horizontal = 5
resolucao_vertical = 5
camara = Camara(posicao, olhar_para, vertical,
distancia_olho_plano_projecao, largura_retangulo_projecao,
altura_retangulo_projecao, resolucao_horizontal,
resolucao_vertical)
# teste a __str__
print(camara)
direcao_olho = raio.vetor_diretor
cor_face = self.get_cor_face(face_int, pi, direcao_olho)
return cor_face
# 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]
# teste ao construtor - camara
camara_posicao = Ponto3D(0.0, 0.0, 2.0)
olhar_para = Ponto3D(0.0, 0.0, 0.0)
vertical = Vetor3D(0.0, 1.0, 0.0)
distancia_olho_plano_projecao = 1.5
largura_retangulo_projecao = 2.0
"""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)")
# 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,
luz_intensidade_especular,
)
# olho
olho = Ponto3D(-1.0, 0.0, 1.0)
# normal
n_pontos = 100
incremento = 0.02 # 2.0/100.0
raise (ErroPontosCoincidentes)
self.vetor_diretor = direcao.normaliza()
def __str__(self):
"""Retorna uma string que representa a reta."""
return("Reta(" + str(self.origem) + ", " + str(self.destino) + ", " \
+ str(self.vetor_diretor) + ")")
# testes
if __name__ == "__main__":
# teste ao construtor
p1 = Ponto3D(0.0, 0.0, 0.0)
p2 = Ponto3D(1.0, 2.0, 3.0)
r1 = Reta(p1, p2)
print("Até aqui não foram lançadas exceções.")
# teste à exceção ErroPontosCoincidentes
try:
r2 = Reta(p2, p2)
except ErroPontosCoincidentes:
print("Ao tentar definir-se a reta r2 = Reta(p2, p2)")
print("foi lançada a exceção ErroPontosCoincidentes.")
print("A execução foi interrompida. r2 não ficou definida.")
# teste a __str__
print(r1)
# i_ significa intensidade_
# a posição é um objeto Ponto3D
# as intensidades são objetos CorRGB
self.posicao = posicao
self.intensidade_ambiente = intensidade_ambiente
self.intensidade_difusa = intensidade_difusa
self.intensidade_especular = intensidade_especular
def __str__(self):
return ("Luz(" + str(self.posicao) + ", " +
str(self.intensidade_ambiente) + ", " +
str(self.intensidade_difusa) + ", " +
str(self.intensidade_especular) + ")")
if __name__ == "__main__":
# teste ao construtor
posicao = Ponto3D(1.0, 0.0, 3.0)
intensidade_ambiente = CorRGB(0.1, 0.2, 0.3)
intensidade_difusa = CorRGB(0.4, 0.5, 0.6)
intensidade_especular = CorRGB(0.7, 0.8, 0.9)
luz = Luz(posicao, intensidade_ambiente, intensidade_difusa,
intensidade_especular)
# teste a __str__
print(luz)