Example #1
0
def diminuiEscala(figura, scaleVar, janela, largura, altura):
    timeInicio = pygame.time.get_ticks()
    time = pygame.time.get_ticks()
    while (time - timeInicio < 2000):

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()

        scaleVar -= 0.05

        figura = poligonos.setCentro(figura)
        figura = scale(figura, scaleVar)

        cX1 = figura.centro[0]
        cY1 = figura.centro[1]
        cZ1 = figura.centro[2]
        figura = translate(figura, largura / 2 - cX1, altura / 2 - cY1, -cZ1)

        plano.projetaPoligonoFaces(figura, janela)

        time = pygame.time.get_ticks()
        clock.tick(60)
        pygame.display.update()
        janela.fill((0, 0, 0, 1))

    return figura
Example #2
0
def rotate(figura, x, y, z, fator):

    deslocamentoX = figura.getDeslocamentoX()
    deslocamentoY = figura.getDeslocamentoY()
    sentidoX = figura.getSentidoX()
    sentidoY = figura.getSentidoY()
    moveX = figura.getMoveX()
    moveY = figura.getMoveY()
    scale = figura.getScale()

    cos = m.cos(fator)
    sin = m.sin(fator)
    Rx = np.array([[1, 0, 0, 0], [0, cos, -sin, 0], [0, sin, cos, 0],
                   [0, 0, 0, 1]])

    Ry = np.array([[cos, 0, sin, 0], [0, 1, 0, 0], [-sin, 0, cos, 0],
                   [0, 0, 0, 1]])

    Rz = np.array([[cos, -sin, 0, 0], [sin, cos, 0, 0], [0, 0, 1, 0],
                   [0, 0, 0, 1]])
    vertices = poligonos.get_vertices(figura)
    temp = []
    arestas = poligonos.get_arestas(figura)
    for a in vertices:
        temp.append(a)
    B = np.array(temp)
    if (x == 1):
        C = np.dot(B, Rx)
        figura = poligonos.Poligono(arestas, figura.centro,
                                    poligonos.get_faces(figura))
        figura.addVertice(C)
        figura.addVerticeO(C)
    elif (y == 1):
        C = np.dot(B, Ry)
        figura = poligonos.Poligono(arestas, figura.centro,
                                    poligonos.get_faces(figura))
        figura.addVertice(C)
        figura.addVerticeO(C)
    elif (z == 1):
        C = np.dot(B, Rz)
        figura = poligonos.Poligono(arestas, figura.centro,
                                    poligonos.get_faces(figura))
        figura.addVertice(C)
        figura.addVerticeO(C)

    figura = poligonos.setCentro(figura)
    figura.setDeslocamentoX(deslocamentoX)
    figura.setDeslocamentoY(deslocamentoY)
    figura.setSentidoX(sentidoX)
    figura.setSentidoY(sentidoY)
    figura.setMoveX(moveX)
    figura.setMoveY(moveY)
    figura.setScale(scale)

    return figura
Example #3
0
def translate(figura, x, y, z):

    deslocamentoX = figura.deslocamentoX()
    deslocamentoY = figura.deslocamentoY()

    if (quadrosChave.quadroChaveTransX(figura)):

        if (figura.getMoveY()):
            figura.setMoveY(False)
            figura.setSentidoY(False)
        else:
            figura.setMoveY(True)

        figura.inverteSentidoX()

    if (quadrosChave.quadroChaveTransY(figura)):
        figura.inverteSentidoY()

    T = np.array([[1, 0, 0, x + deslocamentoX], [0, 1, 0, y + deslocamentoY],
                  [0, 0, 1, z], [0, 0, 0, 1]])
    vertices = poligonos.get_vertices(figura)
    temp = []
    arestas = poligonos.get_arestas(figura)
    for a in vertices:
        temp.append(a)
    B = np.array(temp)

    C = []
    for i in B:
        temp = np.dot(T, [[i[0]], [i[1]], [i[2]], [i[3]]])
        linha = []
        for j in temp:
            linha.append(j[0])

        C.append(linha)
    fig = poligonos.Poligono(arestas, figura.centro,
                             poligonos.get_faces(figura))

    fig.addVertice(C)
    fig.addVerticeO(C)
    fig = poligonos.setCentro(fig)
    fig.setDeslocamentoX(deslocamentoX)
    fig.setDeslocamentoY(deslocamentoY)
    fig.setSentidoX(figura.getSentidoX())
    fig.setSentidoY(figura.getSentidoY())
    fig.setMoveX(figura.getMoveX())
    fig.setMoveY(figura.getMoveY())
    fig.setScale(figura.getScale())

    return fig
Example #4
0
def reflect(figura, qx, qy, qz):

    x = 1
    y = 1
    z = 1

    if (qx == True):
        y = -1
        z = -1
    if (qy == True):
        x = -1
        z = -1
    if (qz == True):
        x = -1
        y = -1

    A = np.array([[x, 0, 0, 0], [0, y, 0, 0], [0, 0, z, 0], [0, 0, 0, 1]])
    vertices = poligonos.get_vertices(figura)
    temp = []
    arestas = poligonos.get_arestas(figura)
    for a in vertices:
        temp.append(a)
    B = np.array(temp)

    C = np.dot(B, A)

    fig = poligonos.Poligono(arestas, figura.centro,
                             poligonos.get_faces(figura))
    fig.addVertice(C)
    fig.addVerticeO(C)
    fig = poligonos.setCentro(fig)
    fig.setDeslocamentoX(figura.getDeslocamentoX())
    fig.setDeslocamentoY(figura.getDeslocamentoY())
    fig.setSentidoX(figura.getSentidoX())
    fig.setSentidoY(figura.getSentidoY())
    fig.setMoveX(figura.getMoveX())
    fig.setMoveY(figura.getMoveY())
    fig.setScale(figura.getScale())

    return fig
Example #5
0
def scale(figura, fator):

    if (figura.getScale() != 0):
        aux = figura.getScale()
        figura.setScale(0)
        figura = scale(figura, 1 / aux)

    EX = EY = EZ = fator
    A = np.array([[EX, 0, 0, 0], [0, EY, 0, 0], [0, 0, EZ, 0], [0, 0, 0, 1]])

    vertices = poligonos.get_vertices(figura)

    centro = figura.getCentro()

    vertices = transladaParaOrigem(vertices, True, centro)
    temp = []
    arestas = poligonos.get_arestas(figura)
    for a in vertices:
        temp.append(a)
    B = np.array(temp)

    C = np.dot(B, A)

    C = transladaParaOrigem(C, False, centro)

    fig = poligonos.Poligono(arestas, figura.centro,
                             poligonos.get_faces(figura))
    fig.addVertice(C)
    fig = poligonos.setCentro(fig)
    fig.setDeslocamentoX(figura.getDeslocamentoX())
    fig.setDeslocamentoY(figura.getDeslocamentoY())
    fig.setSentidoX(figura.getSentidoX())
    fig.setSentidoY(figura.getSentidoY())
    fig.setMoveX(figura.getMoveX())
    fig.setMoveY(figura.getMoveY())
    fig.setScale(fator)

    return fig
Example #6
0
def shearing(figura, x, y, z, matriz):

    if (matriz == 1):
        S = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [x, y, 1, 0], [0, 0, 0, 1]])

    elif (matriz == 2):
        S = np.array([[1, 0, 0, 0], [x, 1, z, 0], [0, 0, 1, 0], [0, 0, 0, 1]])

    elif (matriz == 3):

        S = np.array([[1, y, z, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]])

    else:  #Caso não digite nada multiplica pela identidade.
        S = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]])

    vertices = poligonos.get_vertices(figura)
    temp = []
    arestas = poligonos.get_arestas(figura)
    for a in vertices:
        temp.append(a)
    B = np.array(temp)

    R = np.dot(B, S)

    fig = poligonos.Poligono(arestas, figura.centro,
                             poligonos.get_faces(figura))
    fig.addVertice(R)
    fig = poligonos.setCentro(fig)
    fig.setDeslocamentoX(figura.getDeslocamentoX())
    fig.setDeslocamentoY(figura.getDeslocamentoY())
    fig.setSentidoX(figura.getSentidoX())
    fig.setSentidoY(figura.getSentidoY())
    fig.setMoveX(figura.getMoveX())
    fig.setMoveY(figura.getMoveY())
    fig.setScale(figura.getScale())

    return fig
Example #7
0
def main():
    pygame.display.init()
    size = (largura, altura)
    janela = pygame.display.set_mode(size, 0, 0, 0)

    pygame.display.set_caption(
        "Computação Gráfica com um grupinho do barulho mais que bacana!!")
    pygame.display.set_caption("Ei você, vai se fudê!!")
    pygame.display.set_caption("Zamp#")
    pygame.display.set_caption("ComPutaSão Gráfica")
    pygame.display.set_caption("CARALHOW O EULLER É FODA!!!!")

    background = pygame.Surface(janela.get_size(), flags=pygame.SRCALPHA)
    background = background.convert_alpha()
    background.fill((0, 0, 0))

    fig2 = poligonos.get_zig()
    fig2 = poligonos.setCentro(fig2)
    scale = 10
    fig2 = transform.scale(fig2, scale)

    while True:

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()

        scale = fig2.getScale()
        fig2 = transform.aumentaEscala(fig2, scale, janela, largura,
                                       altura)  #Função para aumentar escala
        scale = fig2.getScale()
        fig2 = transform.diminuiEscala(fig2, scale, janela, largura,
                                       altura)  #Função para reduzir escala

        fig3 = poligonos.calcula_figura_curva(
            fig2)  #Cria uma figura com curvas
        #fig3 = poligonos.setCentro(fig3)
        fig3 = transform.reflect(fig3, False, True,
                                 False)  #Faz a figura refletir no eixo Y
        timeInicio = pygame.time.get_ticks()
        fig3.setDeslocamentoX(fig2.getDeslocamentoX())
        fig3.setDeslocamentoY(fig2.getDeslocamentoY())
        fig3.setSentidoX(fig2.getSentidoX())
        fig3.setSentidoY(fig2.getSentidoY())
        fig3.setMoveX(fig2.getMoveX())
        fig3.setMoveY(fig2.getMoveY())
        fig3.setScale(fig2.getScale())

        #fig3 = transform.translate(fig3, largura / 2 - cX1, altura / 2 - cY1, -cZ1)
        plano.projetaPoligonoWireframe(fig3, janela)
        time = 0
        while (time - timeInicio <
               800):  #Exibe a imagem da figura refletida por um tempo
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    pygame.quit()
                    quit()

            cX1 = fig3.centro[0]
            cY1 = fig3.centro[1]
            cZ1 = fig3.centro[2]
            fig3 = transform.translate(fig3, largura / 2 - cX1,
                                       altura / 2 - cY1, -cZ1)

            plano.projetaPoligonoWireframe(fig3, janela)
            time = pygame.time.get_ticks()
            clock.tick(60)
            pygame.display.update()
            janela.fill((0, 0, 0, 1))

        fig3 = transform.reflect(fig3, True, False,
                                 False)  #Faz a figura refletir no eixo X
        timeInicio = pygame.time.get_ticks()
        time = 0
        plano.projetaPoligonoWireframe(fig3, janela)
        while (time - timeInicio <
               800):  #Exibe a imagem da figura refletida por um tempo
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    pygame.quit()
                    quit()

            cX1 = fig3.centro[0]
            cY1 = fig3.centro[1]
            cZ1 = fig3.centro[2]
            fig3 = transform.translate(fig3, largura / 2 - cX1,
                                       altura / 2 - cY1, -cZ1)
            plano.projetaPoligonoWireframe(fig3, janela)

            time = pygame.time.get_ticks()
            clock.tick(60)
            pygame.display.update()
            janela.fill((0, 0, 0, 1))

        fig3 = transform.reflect(fig3, False, False,
                                 True)  #Faz a figura refletir no eixo Z
        timeInicio = pygame.time.get_ticks()
        time = 0
        plano.projetaPoligonoWireframe(fig3, janela)
        while (time - timeInicio <
               800):  #Exibe a imagem da figura refletida por um tempo
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    pygame.quit()
                    quit()

            cX1 = fig3.centro[0]
            cY1 = fig3.centro[1]
            cZ1 = fig3.centro[2]
            fig3 = transform.translate(fig3, largura / 2 - cX1,
                                       altura / 2 - cY1, -cZ1)
            plano.projetaPoligonoWireframe(fig3, janela)

            time = pygame.time.get_ticks()
            clock.tick(60)
            pygame.display.update()
            janela.fill((0, 0, 0, 1))

        fig2 = transform.transladaRotacionando(
            fig2, janela, largura,
            altura)  #Função para mover e rotacionar a figura

        fig2 = transform.aumentaCisalhamento(
            fig2, janela, 1)  #Função para aumentar o cisalhamento no eixo xy
        fig2 = transform.diminuiCisalhamento(
            fig2, janela, 1)  #Função para diminuir o cisalhamento no eixo xy

        fig2 = transform.aumentaCisalhamento(
            fig2, janela, 2)  #Função para aumentar o cisalhamento no eixo xz
        fig2 = transform.diminuiCisalhamento(
            fig2, janela, 2)  #Função para diminuir o cisalhamento no eixo xz

        fig2 = transform.aumentaCisalhamento(
            fig2, janela, 3)  #Função para aumentar o cisalhamento no eixo yz
        fig2 = transform.diminuiCisalhamento(
            fig2, janela, 3)  #Função para diminuir o cisalhamento no eixo xz
        fig2 = transform.transladaRotacionando(fig2, janela, largura, altura)