Exemplo n.º 1
0
class TesteTransformacoes(unittest.TestCase):

    def setUp(self):
        self.objeto = Objeto([array([2, 2]), array([4, 4]), array([3, 6])])

    def teste_vertices(self):
        self.assertEqual(self.objeto.vertices.__len__(),3)
        self.assertTrue(allclose(self.objeto.vertices[0], array([2, 2])))
        self.assertFalse(allclose(self.objeto.vertices[1], array([2, 2])))

    def teste_centro_inteiro(self):
        self.assertTrue(allclose(self.objeto.centro(), array([3,4])))

    def teste_centro_real(self):
        self.objeto.vertices.append(array([6,9]))
        self.assertTrue(allclose(self.objeto.centro(), array([3.75,5.25])))

    def teste_centro_objeto_sem_vertices(self):
        objeto = Objeto()
        self.assertEqual(objeto.centro(), None)

    def teste_trasladar(self):
        self.objeto.transladar(0,0)
        self.assertTrue(allclose(self.objeto.vertices[0], array([-1, -2])))
        self.assertTrue(allclose(self.objeto.vertices[1], array([1, 0])))
        self.assertTrue(allclose(self.objeto.vertices[2], array([0, 2])))

    def teste_proporcao_fixa_vertice_ponto_para_aumentar(self):
        ponto = array([1,1])
        vertice_redimencao = self.objeto.vertices[0]
        proporcao = self.objeto.proporcao_fixa_vertice_ponto(vertice_redimencao, ponto)
        self.assertEqual(proporcao, 1.6124515496597098)

    def teste_proporcao_fixa_vertice_ponto_para_diminuir(self):
        ponto = array([2.5,3])
        vertice_redimencao = self.objeto.vertices[0]
        proporcao = self.objeto.proporcao_fixa_vertice_ponto(vertice_redimencao, ponto)
        self.assertEqual(proporcao, 0.5)

    def teste_redimensionar(self):
        self.objeto.redimensionar(1.6124515496597098)
        self.assertTrue(allclose(self.objeto.vertices[0], array([1.38754845, 0.7750969])))
        self.assertTrue(allclose(self.objeto.vertices[1], array([4.61245155, 4.0])))
        self.assertTrue(allclose(self.objeto.vertices[2], array([3.0, 7.2249031])))

    def teste_angulo_vertice_ponto(self):
        self.objeto = Objeto([array([1,0])])
        ponto = array([0,1])
        self.assertAlmostEqual(self.objeto.angulo_vertice_ponto(self.objeto.vertices[0],ponto), 1.5707963267948966)
        ponto = array([1,1])
        self.assertAlmostEqual(self.objeto.angulo_vertice_ponto(self.objeto.vertices[0],ponto), 0.78539816339744828)

    def teste_rotacionar(self):
        self.objeto.rotacionar(0.52359877559829882)
        self.assertAlmostEqual(self.objeto.vertices[0][X], 3.13, 2)
        self.assertAlmostEqual(self.objeto.vertices[0][Y], 1.77, 2)
        self.assertAlmostEqual(self.objeto.vertices[1][X], 3.87, 2)
        self.assertAlmostEqual(self.objeto.vertices[1][Y], 4.5)
        self.assertAlmostEqual(self.objeto.vertices[2][X], 2.0)
        self.assertAlmostEqual(self.objeto.vertices[2][Y], 5.73, 2)

    def teste_refletir_horizontal(self):
        self.objeto.refletir("x")
        self.assertTrue(allclose(self.objeto.vertices[0], array([2, -2])))
        self.assertTrue(allclose(self.objeto.vertices[1], array([4, -4])))
        self.assertTrue(allclose(self.objeto.vertices[2], array([3, -6])))

    def teste_refletir_vertical(self):
        self.objeto.refletir("vertical")
        self.assertTrue(allclose(self.objeto.vertices[0], array([-2, 2])))
        self.assertTrue(allclose(self.objeto.vertices[1], array([-4, 4])))
        self.assertTrue(allclose(self.objeto.vertices[2], array([-3, 6])))

    def teste_refletir_origem(self):
        self.objeto.refletir("origem")
        self.assertTrue(allclose(self.objeto.vertices[0], array([-2, -2])))
        self.assertTrue(allclose(self.objeto.vertices[1], array([-4, -4])))
        self.assertTrue(allclose(self.objeto.vertices[2], array([-3, -6])))

    def teste_vertice_proximo(self):
        self.objeto = Objeto([array([20, 20]), array([40, 40]), array([30, 60])])
        self.assertEqual(self.objeto.vertice_proximo(23,22), 0)
        self.assertEqual(self.objeto.vertice_proximo(37,38), 1)
        self.assertEqual(self.objeto.vertice_proximo(44,44), None)
Exemplo n.º 2
0
class Interface:

    def __init__(self):
        self.objeto = Objeto()
        self.limite_x = 300
        self.limite_y = 300
        self.tarefa = DESENHAR
        self.indice_vertice_selecionado = None
        self.eixo_cisalhar = None

    def init(self):
        glClearColor(1, 1, 1, 1)

    def plano_cartesiano(self):
        glColor3f(0, 0, 0)
        glLineWidth(1)

        glBegin(GL_LINES)
        glVertex2f(-self.limite_x, 0)
        glVertex2f(self.limite_x, 0)
        glVertex2f(0, -self.limite_y)
        glVertex2f(0, self.limite_y)
        glEnd()

    def display(self):
        glClear(GL_COLOR_BUFFER_BIT)

        glLoadIdentity()
        gluOrtho2D(-self.limite_x,self.limite_x,-self.limite_y,self.limite_y)

        self.plano_cartesiano()
        self.objeto.desenha("poligono")
        glFlush()

    def reshape(self, largura, altura):
        glViewport(0 , 0, largura, altura)
        self.limite_x = largura/2
        self.limite_y = altura/2


    def gerencia_mouse(self, button, state, x, y):
        # As duas linhas seguintes servem para ajeitar as coordenadas recebidas
        # pelo clique do mouse de acordo com as coordenadas de tela.
        # As coordenadas de mouse numa tela de 200x200, vão de (0,0) no canto
        # superior esquerdo, até (199,199) no canto inferior direito.
        x = x - self.limite_x
        y = self.limite_y - y

        if self.tarefa == DESENHAR:
            if(button == GLUT_LEFT_BUTTON):
                if(state == GLUT_UP):
                    self.objeto.vertices.append(array([x, y]))
                    self.objeto.desenha("pontos")
            if(button == GLUT_RIGHT_BUTTON):
                if(state == GLUT_DOWN):
                    self.objeto.desenha("poligono")
                    self.objeto.centro()
                    self.tarefa = NENHUMA

        elif self.tarefa == TRANSLADAR:
            if(button == GLUT_LEFT_BUTTON):
                if(state == GLUT_DOWN):
                    self.objeto.transladar(x,y)
                    glutPostRedisplay()

        elif self.tarefa == ROTACIONAR:
            if(button == GLUT_LEFT_BUTTON):
                if(state == GLUT_DOWN):
                    self.indice_vertice_selecionado = self.objeto.vertice_proximo(x,y)
                elif(state == GLUT_UP):
                    self.indice_vertice_selecionado = None

        elif self.tarefa == REDIMENSIONAR:
            if(button == GLUT_LEFT_BUTTON):
                if(state == GLUT_DOWN):
                    self.indice_vertice_selecionado = self.objeto.vertice_proximo(x,y)
                elif(state == GLUT_UP):
                    self.indice_vertice_selecionado = None

        elif self.tarefa == CISALHAR:
            if(button == GLUT_LEFT_BUTTON):
                if(state == GLUT_DOWN):
                    self.eixo_cisalhar = "x"
                    self.indice_vertice_selecionado = self.objeto.vertice_proximo(x,y)
                elif(state == GLUT_UP):
                    self.indice_vertice_selecionado = None
            if(button == GLUT_RIGHT_BUTTON):
                if(state == GLUT_DOWN):
                    self.eixo_cisalhar = "y"
                    self.indice_vertice_selecionado = self.objeto.vertice_proximo(x,y)
                elif(state == GLUT_UP):
                    self.indice_vertice_selecionado = None

    def gerencia_motion(self, x, y):
        # As duas linhas seguintes servem para ajeitar as coordenadas recebidas
        # pelo clique do mouse de acordo com as coordenadas de tela.
        # As coordenadas de mouse numa tela de 200x200, vão de (0,0) no canto
        # superior esquerdo, até (199,199) no canto inferior direito.
        x = x - self.limite_x
        y = self.limite_y - y

        if self.tarefa == TRANSLADAR:
            self.objeto.transladar(x,y)
            glutPostRedisplay()

        elif self.tarefa == ROTACIONAR:
            if self.indice_vertice_selecionado != None:
                vertice_rotacao = self.objeto.vertices[self.indice_vertice_selecionado]
                ponto = array([x,y])
                angulo = self.objeto.angulo_vertice_ponto(vertice_rotacao,ponto)
                self.objeto.rotacionar(angulo)
                glutPostRedisplay()

        elif self.tarefa == REDIMENSIONAR:
            if self.indice_vertice_selecionado != None:
                vertice_redimencao = self.objeto.vertices[self.indice_vertice_selecionado]
                ponto = array([x,y])
                proporcao = self.objeto.proporcao_fixa_vertice_ponto(vertice_redimencao,ponto)
                self.objeto.redimensionar(proporcao)
                glutPostRedisplay()

        elif self.tarefa == CISALHAR:
            if self.indice_vertice_selecionado != None:
                vertice_cisalhamento = self.objeto.vertices[self.indice_vertice_selecionado]
                ponto = array([x,y])
#                proporcao = self.objeto.proporcao_fixa_vertice_ponto(ponto,vertice_cisalhamento)
                self.objeto.cisalhar(vertice_cisalhamento, ponto, self.eixo_cisalhar)
                glutPostRedisplay()

    def menu_principal(self, opcao):
        if opcao == DESENHAR:
            self.tarefa = DESENHAR
            self.objeto.vertices = []
            glutPostRedisplay()
        return 0

    def menu_transformacoes(self, opcao):
        if opcao == TRANSLADAR:
            self.tarefa = TRANSLADAR
        elif opcao == REDIMENSIONAR:
            self.tarefa = REDIMENSIONAR
        elif opcao == ROTACIONAR:
            self.tarefa = ROTACIONAR
        elif opcao == CISALHAR:
            self.tarefa = CISALHAR

    def menu_refletir(self, opcao):
        if opcao == REFLETIR_H:
            self.objeto.refletir("x")
            self.tarefa = REFLETIR_H
            glutPostRedisplay()
        elif opcao == REFLETIR_V:
            self.objeto.refletir("y")
            self.tarefa = REFLETIR_V
            glutPostRedisplay()
        elif opcao == REFLETIR_O:
            self.objeto.refletir("o")
            self.tarefa = REFLETIR_O
            glutPostRedisplay()

    def cria_menu(self):

        submenu_refletir = glutCreateMenu(self.menu_refletir)
        glutAddMenuEntry("Horizontalmente", REFLETIR_H)
        glutAddMenuEntry("Verticalmente", REFLETIR_V)
        glutAddMenuEntry("Centralmente", REFLETIR_O)

        submenu_transformacoes = glutCreateMenu(self.menu_transformacoes)
        glutAddMenuEntry("Transladar", TRANSLADAR)
        glutAddMenuEntry("Redimensionar", REDIMENSIONAR)
        glutAddMenuEntry("Rotacionar", ROTACIONAR)
        glutAddMenuEntry("Cisalhar", CISALHAR)
        glutAddSubMenu("Refletir", submenu_refletir)

        menu = glutCreateMenu(self.menu_principal)
        glutAddMenuEntry("Desenhar", DESENHAR)
        glutAddSubMenu("Transformacoes", submenu_transformacoes)

        glutAttachMenu(GLUT_MIDDLE_BUTTON)

    def main(self):
        glutInit(argv)

        glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB)
        glutInitWindowSize(self.limite_x*2,self.limite_y*2)
        glutCreateWindow("Transformacoes")

        glutDisplayFunc(self.display)
        glutReshapeFunc(self.reshape)
        glutMouseFunc(self.gerencia_mouse)
        glutMotionFunc(self.gerencia_motion)
        self.init()
        self.cria_menu()
        glutMainLoop()