示例#1
0
void desenharVenus(GLuint texture, GLUquadric *  Q)
{
	glPushMatrix();
	glRotatef(orbitalTiltVenus,0.0,0.0,1.0);
	angVenus += ((2*PI)/velVenus)*timeFactor;

	posicoes[2][0]=distFactor*distSolVenus*sin(angVenus);
	posicoes[2][1]=distFactor*distSolVenus*sin(angVenus) * sin(orbitalTiltVenus*(PI/180)) ;
	posicoes[2][2]=distFactor*distSolVenus*cos(angVenus);
	raios[2]=raioVenus*scale;

	//colisao planeta -> nave
	if((cameraMode==0 && haColisao(camZ,camX,camY,2)) || (cameraMode == 1 && haColisaoNave2(camZ,camX,camY,camlookZ,camlookX,camlookY,2)) )
		afastaCamara(2);

	glTranslatef(distFactor*distSolVenus*sin(angVenus), 0, distFactor*distSolVenus*cos(angVenus));

	//glColor3f(0.6,0.5,0.1);//castanho
	angRotVenus += (360/velRVenus)*timeFactor;
	rotacao(angRotVenus,axisTiltVenus);
	glRotatef(90,1,0,0);
	glEnable (GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, texture);
	
	if(sphereInFrustum(posicoes[2],raios[2]))
		gluSphere (Q,scale*raioVenus,calcularFatias(2),32);
	
	glDisable(GL_TEXTURE_2D);
	glPopMatrix();
	if(orbitas)draw_orbita(distFactor*distSolVenus,90,0.0,orbitalTiltVenus);
}
示例#2
0
void desenharNeptuno(GLuint texture, GLUquadric *  Q)
{
	glPushMatrix();
	glRotatef(orbitalTiltNeptuno,0.0,0.0,1.0);
	angNeptuno += ((2*PI)/velNeptuno)*timeFactor;
	
	posicoes[18][0]=distFactor*distSolNeptuno*sin(angNeptuno);
	posicoes[18][1]=distFactor*distSolNeptuno*sin(angNeptuno) * sin(orbitalTiltNeptuno*(PI/180)) ;
	posicoes[18][2]=distFactor*distSolNeptuno*cos(angNeptuno);
	raios[18]=raioNeptuno*scale;

	//colisao planeta -> nave
	if((cameraMode==0 && haColisao(camZ,camX,camY,18)) || (cameraMode == 1 && haColisaoNave2(camZ,camX,camY,camlookZ,camlookX,camlookY,18)) )
		afastaCamara(18);

	glTranslatef(distFactor*distSolNeptuno*sin(angNeptuno), 0, distFactor*distSolNeptuno*cos(angNeptuno));

	//glColor3f(0.12,0.432,0.123);//verde
	angRotNeptuno += (360/velRNeptuno)*timeFactor;
	rotacao(angRotNeptuno,axisTiltNeptuno);
	glEnable (GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, texture);
	glRotatef(-90,1,0,0);
	
	if(sphereInFrustum(posicoes[18],raios[18]))
		gluSphere (Q,scale*raioNeptuno,calcularFatias(18),32);
	
	glDisable(GL_TEXTURE_2D);
	glPopMatrix();
	
	if(orbitas)draw_orbita(distFactor*distSolNeptuno,90,0.0,orbitalTiltNeptuno);
}
示例#3
0
void desenharIapetus(GLuint texture, GLUquadric * Q)
{
	glPushMatrix();
	glColor3f(1,1,1);//branco
	if(orbitas)draw_orbita(distFactor*scale*distSaturnoIapetus,90,0.0,0.0);
	
	posicoes[15][0]=0;
	posicoes[15][1]=0.0;
	posicoes[15][2]=0;
	raios[15]=raioIapetus*scale;

	//colisao planeta -> nave
	//if((cameraMode==0 && haColisao(camZ,camX,camY,15)) || (cameraMode == 1 && haColisaoNave2(camZ,camX,camY,camlookZ,camlookX,camlookY,15)) )
	//	afastaCamara(15);

	glTranslatef(distFactor*scale*distSaturnoIapetus*sin(velRJapeto), 0, distFactor*scale*distSaturnoIapetus*cos(velRJapeto));

	angRotIapetus += (360/velRJapeto)*timeFactor;
	rotacao(angRotIapetus,0.0);

	glEnable (GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, texture);
	
	//if(sphereInFrustum(posicoes[15],raios[15]))
		gluSphere (Q,scale*raioIapetus,32,32);
	
	glDisable(GL_TEXTURE_2D);
	
	glPopMatrix();
}
示例#4
0
void desenharCalisto(GLuint texture, GLUquadric * Q)
{
	glPushMatrix();
	//glColor3f(1,1,1);//branco
	if(orbitas)draw_orbita(distFactor*scale*distJupiterCalisto,90,0.0,0.0);
	angCalisto += (((2*PI)/velLua)-((360/velRJupiter)*(PI/180)))*timeFactor;
	
	posicoes[11][0]=0;
	posicoes[11][1]=0.0;
	posicoes[11][2]=0;
	raios[11]=raioCalisto*scale;
	
	//colisao planeta -> nave
	//if((cameraMode==0 && haColisao(camZ,camX,camY,11)) || (cameraMode == 1 && haColisaoNave2(camZ,camX,camY,camlookZ,camlookX,camlookY,11)) )
	//	afastaCamara(11);

	glTranslatef(distFactor*scale*distJupiterCalisto*sin(angCalisto), 0, distFactor*scale*distJupiterCalisto*cos(angCalisto));

	angRotCalisto += (360/velRCalisto)*timeFactor;
	rotacao(angRotCalisto,0.0);
	glRotatef(-90,1,0,0);
	glEnable (GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, texture);

	//if(sphereInFrustum(posicoes[11],raios[11]))
		gluSphere (Q,scale*raioCalisto,32,32);
	
	glDisable(GL_TEXTURE_2D);
	glPopMatrix();
}
示例#5
0
void desenharDeimos(GLuint texture, GLUquadric * Q)
{
	glPushMatrix();
	
	if(orbitas)draw_orbita(scale*distMarteDeimos,90,0.0,0.0);
	angDeimos += (((2*PI)/velLua)-((360/velRMarte)*(PI/180)))*timeFactor;

	posicoes[6][0]=0;
	posicoes[6][1]=0.0;
	posicoes[6][2]=0;
	raios[6]=raioDeimos*scale;

	//colisao planeta -> nave
	//if((cameraMode==0 && haColisao(camZ,camX,camY,6)) || (cameraMode == 1 && haColisaoNave2(camZ,camX,camY,camlookZ,camlookX,camlookY,6)) )
	//	afastaCamara(6);

	glTranslatef(scale*distMarteDeimos*sin(angDeimos), 0, scale*distMarteDeimos*cos(angDeimos));

	angRotDeimos += (360/velRDeimos)*timeFactor;
	rotacao(angRotDeimos,0.0);

	glRotatef(-90,1,0,0);
	glEnable (GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, texture);

	//if(sphereInFrustum(posicoes[6],raios[6]))
		gluSphere (Q,scale*raioDeimos,32,32);
	
	glDisable(GL_TEXTURE_2D);
	glPopMatrix();
}
示例#6
0
void desenharLua(GLuint texture, GLUquadric * Q)
{
	glPushMatrix();
	if(orbitas)draw_orbita(distFactor*scale*distTerraLua,90,0.0,0.0);
	angLua += (((2*PI)/velLua)-((360/velRTerra)*(PI/180)))*timeFactor;
	
	posicoes[3][0]=0;
	posicoes[3][1]=0;
	posicoes[3][2]=0;
	raios[3]=raioLua*scale;

	//colisao planeta -> nave
	//if((cameraMode==0 && haColisao(camZ,camX,camY,3)) || (cameraMode == 1 && haColisaoNave2(camZ,camX,camY,camlookZ,camlookX,camlookY,3)) )
	//	afastaCamara(3);

	glTranslatef(distFactor*scale*distTerraLua*sin(angLua), 0, distFactor*scale*distTerraLua*cos(angLua));

    glRotatef(-90,1,0,0);
	//glColor3f(1,1,1);//branco
	angRotLua += (360/velRLua)*timeFactor;
	rotacao(angRotLua,axisTiltLua);
	glEnable (GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, texture);
	
	//if(sphereInFrustum(posicoes[3],raios[3]))
		gluSphere (Q,scale*raioLua,32,32);
	
	glDisable(GL_TEXTURE_2D);
	glPopMatrix();
}
示例#7
0
void desenharJupiter(GLuint texture, GLUquadric *  Q, GLuint texture2, GLUquadric *  Q2)
{
	glPushMatrix();
	glRotatef(orbitalTiltJupiter,0.0,0.0,1.0);
	angJupiter += ((2*PI)/velJupiter)*timeFactor;
	
	posicoes[12][0]=distFactor*distSolJupiter*sin(angJupiter);
	posicoes[12][1]=distFactor*distSolJupiter*sin(angJupiter) * sin(orbitalTiltJupiter*(PI/180)) ;
	posicoes[12][2]=distFactor*distSolJupiter*cos(angJupiter);
	raios[12]=raioJupiter*scale;

	//colisao planeta -> nave
	if((cameraMode==0 && haColisao(camZ,camX,camY,12)) || (cameraMode == 1 && haColisaoNave2(camZ,camX,camY,camlookZ,camlookX,camlookY,12)) )
		afastaCamara(12);

	glTranslatef(distFactor*distSolJupiter*sin(angJupiter), 0, distFactor*distSolJupiter*cos(angJupiter));
	//glColor3f(1,1,0);//amarelo

	angRotJupiter += (360/velRJupiter)*timeFactor;
	rotacao(angRotJupiter,axisTiltJupiter);
	glEnable (GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, texture);
	glRotatef(-90,1,0,0);

	double vec[3];
	vec[0]= posicoes[12][0];
	vec[1]= posicoes[12][1];	
	vec[2]= posicoes[12][2];
	if(sphereInFrustum(posicoes[12],raios[12])){
		gluSphere (Q,scale*raioJupiter,calcularFatias(12),32);
	}
	glDisable(GL_TEXTURE_2D);
	glRotatef(90,1,0,0);
	desenharIO(texture2, Q2);
	desenharEuropa(texture2, Q2);
	desenharGanimedes(texture2, Q2);
	desenharCalisto(texture2, Q2);

	glPopMatrix();
	
	if(orbitas)draw_orbita(distFactor*distSolJupiter,90,0.0,orbitalTiltJupiter);
}
示例#8
0
void desenharSaturno(GLuint texture, GLUquadric *  Q, GLuint texture2, GLUquadric *  Q2)
{
	glPushMatrix();
	glRotatef(orbitalTiltSaturno,0.0,0.0,1.0);
	angSaturno+= ((2*PI)/velSaturno)*timeFactor;
	
	posicoes[16][0]=distFactor*distSolSaturno*sin(angSaturno);
	posicoes[16][1]=distFactor*distSolSaturno*sin(angSaturno) * sin(orbitalTiltSaturno*(PI/180)) ;
	posicoes[16][2]=distFactor*distSolSaturno*cos(angSaturno);
	raios[16]=raioSaturno*scale;

	//colisao planeta -> nave
	if((cameraMode==0 && haColisao(camZ,camX,camY,16)) || (cameraMode == 1 && haColisaoNave2(camZ,camX,camY,camlookZ,camlookX,camlookY,16)) )
		afastaCamara(16);

	glTranslatef(distFactor*distSolSaturno*sin(angSaturno), 0, distFactor*distSolSaturno*cos(angSaturno));

	//glColor3f(1,0,1);//rosa
	angRotSaturno += (360/velRSaturno)*timeFactor;
	rotacao(angRotSaturno,axisTiltSaturno);
	glEnable (GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, texture);
	glRotatef(-90,1,0,0);
	
	if(sphereInFrustum(posicoes[16],raios[16]))
		gluSphere(Q,scale*raioSaturno,calcularFatias(16),32);
	
	glDisable(GL_TEXTURE_2D);

	glRotatef(90,1,0,0);
	
	desenhaAnel();

	desenharRhea(texture2, Q2);
	desenharTitan(texture2, Q2);
	desenharIapetus(texture2, Q2);

	glPopMatrix();
	//glColor3f(1,0,1);//rosa
	if(orbitas)draw_orbita(distFactor*distSolSaturno,90,0.0,orbitalTiltSaturno);
}
示例#9
0
void desenharSol(GLuint texture, GLUquadric *  Q)
{
	glPushMatrix();
	//posSOl
	posicoes[0][0]=0.0;
	posicoes[0][1]=0.0;
	posicoes[0][2]=0.0;
	raios[0]=raioSol;

	angRotSol += (360/velRSol)*timeFactor;
	rotacao(angRotSol,0.0);

	//desenhar cintura de asteroides aqui, so mesmo para ter um efeito de rotaçao
	if(drawCintura)	glCallList(cintura);

	glEnable(GL_LIGHT0);
	glLightfv(GL_LIGHT1, GL_POSITION, lightPos);

	glEnable (GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, texture);
	
	glRotatef(-90,1,0,0);
	double vec[3];
	vec[0]= posicoes[0][0];
	vec[1]= posicoes[0][1];	
	vec[2]= posicoes[0][2];
	
	if(sphereInFrustum(posicoes[0],raios[00])){
		gluSphere (Q,raioSol,calcularFatias(0),32);
	}
	
	glDisable(GL_LIGHT0);
	glEnable(GL_LIGHT1);

	glMaterialfv(GL_FRONT, GL_SPECULAR, nullv);
	glMaterialfv(GL_FRONT, GL_EMISSION, nullv);
	glDisable(GL_TEXTURE_2D);
		
	glPopMatrix();
}
示例#10
0
void desenharTerra(GLuint texture, GLUquadric *  Q, GLuint texture2, GLUquadric *  Q2)
{
	glPushMatrix();
	glRotatef(orbitalTiltTerra,0.0,0.0,1.0);
	angTerra += ((2*PI)/velTerra)*timeFactor;
	

	posicoes[4][0]=distFactor*distSolTerra*sin(angTerra+((2*PI)/velTerra)*timeFactor);
	posicoes[4][1]=distFactor*distSolTerra*sin(angTerra) * sin(orbitalTiltTerra*(PI/180)) ;
	posicoes[4][2]=distFactor*distSolTerra*cos(angTerra+((2*PI)/velTerra)*timeFactor);
	raios[4]=raioTerra*scale;

	//colisao planeta -> nave
	if((cameraMode==0 && haColisao(camZ,camX,camY,4)) || (cameraMode == 1 && haColisaoNave2(camZ,camX,camY,camlookZ,camlookX,camlookY,4)) )
		afastaCamara(4);

	glTranslatef(distFactor*distSolTerra*sin(angTerra), 0, distFactor*distSolTerra*cos(angTerra));

	//glColor3f(0,0,1);//azul
	//angRotTerra += ((0.25*360)/velRTerra)*timeFactor;
	angRotTerra += (360/velRTerra)*timeFactor;

	rotacao(angRotTerra,axisTiltTerra);
	glEnable (GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, texture);
	glRotatef(-90,1,0,0);
	
	if(sphereInFrustum(posicoes[4],raios[4]))
		gluSphere (Q,scale*raioTerra,calcularFatias(4),32);
	
	glDisable(GL_TEXTURE_2D);
	glRotatef(90,1,0,0);
	desenharLua(texture2, Q2);
	glPopMatrix();
	//glColor3f(0,0,1);//azul
	
	if(orbitas)draw_orbita(distFactor*distSolTerra,90,0.0,orbitalTiltTerra);
}
示例#11
0
void desenharMarte(GLuint texture, GLUquadric *  Q, GLuint texture2, GLUquadric *  Q2)
{
	glPushMatrix();
	glRotatef(orbitalTiltMarte,0.0,0.0,1.0);
	angMarte+= ((2*PI)/velMarte)*timeFactor;
	
	posicoes[7][0]=distFactor*distSolMarte*sin(angMarte);
	posicoes[7][1]=distFactor*distSolMarte*sin(angMarte) * sin(orbitalTiltMarte*(PI/180)) ;
	posicoes[7][2]=distFactor*distSolMarte*cos(angMarte);
	raios[7]=raioMarte*scale;

	//colisao planeta -> nave
	if((cameraMode==0 && haColisao(camZ,camX,camY,7)) || (cameraMode == 1 && haColisaoNave2(camZ,camX,camY,camlookZ,camlookX,camlookY,7)) )
		afastaCamara(7);

	glTranslatef(distFactor*distSolMarte*sin(angMarte), 0, distFactor*distSolMarte*cos(angMarte));

	desenharDeimos(texture2, Q2);
	desenharFobos(texture2, Q2);

	//glColor3f(1,0,0);//vermelho
	angRotMarte += (360/velRMarte)*timeFactor;
	rotacao(angRotMarte,axisTiltMarte);
	glEnable (GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, texture);
	glRotatef(-90,1,0,0);
	
	if(sphereInFrustum(posicoes[7],raios[7]))
		gluSphere (Q,scale*raioMarte,calcularFatias(7),32);
	
	glDisable(GL_TEXTURE_2D);
	
	glPopMatrix();
	
	if(orbitas)draw_orbita(distFactor*distSolMarte,90,0.0,orbitalTiltMarte);
}
示例#12
0
int main() {
    Ponto P1,P2,P3,P4,P5;
    float dx,sx,sy,ang;

    //Pontos:
    P1.x=3;
    P1.y=3;
    P1.w=1;
    P2.x=6;
    P2.y=3;
    P3.x=6;
    P3.y=6;
    P4.x=4.5;
    P4.y=8;
    P5.x=3;
    P5.y=6;

    translacao(&P1,3,3);
    escalona(&P1,2,3);
    rotacao(&P1,90);
    espelhaX(&P1);
    espelhaY(&P1);
    espelhaXY(&P1);
}
/*metodo principal, gerencia a janela*/
int main(int argc, char argv[]) {	
	/*janela principal*/
    ALLEGRO_DISPLAY *janela = NULL;

	/*fila de eventos*/
	ALLEGRO_EVENT_QUEUE *filaEvento = NULL;

	/*evento atual*/
	ALLEGRO_EVENT evento;
	
	ALLEGRO_BITMAP *botao_gravar = NULL, *botao_carregar = NULL, *botao_girar_horario = NULL, *botao_girar_antihorario = NULL;
	
	/*ponteiro para um arquivo no dico*/
	FILE *arquivo;
	
	/*definicoes do arquivo*/
	int altura = 0,//altura da imagem
		largura = 0, //largura da imagem
		maxCor = 0;//inteiro que representa tonalidade de cor maxima
	
	char tipo[3];//tipo de PGM
	
	/*estrutura para armazenar os bits do arquivo*/
	unsigned char **data = NULL;
	
	/*sinaliza fechamento da janela*/
	bool fechaJanela = false;
	
	/*sinaliza existencia de arquivo aberto*/
	bool arquivoAberto = false;
 
    /*inicializa bibliotecas*/
    if(!(al_init() && 
		al_install_mouse()&&
		al_init_image_addon()&&
		al_install_keyboard()&&
		al_init_primitives_addon()&&
		(filaEvento = al_create_event_queue()))){
        printf("Erro ao inicializar biblioteca(s)!\n"); 
        return 0;
    }

 // Alocamos o botão para fechar a aplicação
    
    criaBotao(botoes[0], "carregar.bmp");
    
    
    botao_carregar = al_load_bitmap("carregar.bmp"); 
    
    if (!botao_carregar)
    {
        fprintf(stderr, "Falha ao criar botão de carregar a imagem.\n");
        al_destroy_display(janela);
        
        return -1; 
    }
    
        // Alocamos o botão para fechar a aplicação
    botao_gravar = al_load_bitmap("salvar.bmp");
    if (!botao_gravar)
    {
        fprintf(stderr, "Falha ao criar botão de salvar a imagem.\n");
        al_destroy_bitmap(botao_carregar);
        al_destroy_display(janela);
        return -1;
    }
        // Alocamos o botão para fechar a aplicação
    botao_girar_horario = al_load_bitmap("girar_horario.bmp");
    if (!botao_girar_horario)
    {
        fprintf(stderr, "Falha ao criar botão de girar a imagem 90º sentido horario.\n");
       al_destroy_bitmap(botao_carregar);
        al_destroy_bitmap(botao_gravar);
        al_destroy_display(janela);
        return -1;
    }
        // Alocamos o botão para fechar a aplicação
    botao_girar_antihorario = al_load_bitmap("girar_anti.bmp");
    if (!botao_girar_antihorario)
    {
        fprintf(stderr, "Falha ao criar botão de girar a imagem 90º sentido anti-horario.\n");
        al_destroy_bitmap(botao_carregar);
        al_destroy_bitmap(botao_gravar);
        al_destroy_bitmap(botao_girar_horario);
        al_destroy_display(janela);
        return -1;
    }

    /*cria uma janela 640x480*/
    janela = al_create_display(640, 50);

    /*registra os eventos*/
	al_register_event_source(filaEvento, al_get_display_event_source(janela));
	al_register_event_source(filaEvento, al_get_mouse_event_source());
	al_register_event_source(filaEvento, al_get_keyboard_event_source());

	/*preenche a janela com a cor branca*/
    al_clear_to_color(al_map_rgb(255, 255, 255));         

	/*atualiza tela*/
    al_flip_display();
    
	/*fluxo principal da janela*/
	while(fechaJanela == false){
		
        /*pega evento da fila*/
		al_wait_for_event(filaEvento, &evento);

		switch (evento.type) {			
			/*fecha a janela (termina aplicacao)*/
			case ALLEGRO_EVENT_DISPLAY_CLOSE:
				fechaJanela = true;
			break;
			
			/*carrega imagem em mostra na tela*/
			case ALLEGRO_EVENT_MOUSE_BUTTON_UP:
          
           if (evento.mouse.x >= 0 && evento.mouse.x <= 70 && evento.mouse.y <= 50 && evento.mouse.y >= 0) {
				/*caso algum arquivo estiver aberto, limpa dados*/
				if(arquivoAberto==true) {
					desalocaMatriz(data, altura);
					altura =0;
					largura =0;
					maxCor =0;
					arquivoAberto = false;
				}
				if(arquivoAberto==false) {
					/*carrega imagem na matriz*/
                        if(carregaImagem (janela, &altura,&largura, &maxCor, tipo, &data)==-1) {
                            printf("Erro ao desenhar imagem!\n");
                            break;
                        }

					/*sinaliza como arquivo aberto*/
					arquivoAberto = true;

					/*desenha a imagem na janela*/
					desenha(janela, data, altura, largura);
					
					 
				}	
            }
            
            
            if (evento.mouse.x >= 71 && evento.mouse.x <= 140 && evento.mouse.y <= 50 && evento.mouse.y >= 0 && arquivoAberto== true){
                if(arquivoAberto == true) {
					if(gravaImagem(janela, tipo, altura, largura, maxCor, data)==-1) {
						printf("Erro ao salvar imagem!\n");
						break;
					}
				}
				else {
					printf("Nenhum arquivo aberto!\n");			
				}
            }
            
             if (evento.mouse.x >= 141 && evento.mouse.x <= 210 && evento.mouse.y <= 50 && evento.mouse.y >= 0 && arquivoAberto== true)
             {
                 data = rotacao(data, &altura, &largura, 'D');
                 desenha(janela, data, altura, largura);
             }
            
             if (evento.mouse.x >= 211 && evento.mouse.x <= 280 && evento.mouse.y <= 50 && evento.mouse.y >= 0 && arquivoAberto== true){
                                  data = rotacao(data, &altura, &largura, 'E');
                 desenha(janela, data, altura, largura);
                                }
            
			break;
			
		
         case ALLEGRO_EVENT_KEY_DOWN:
		 switch(evento.keyboard.keycode) 
        {
            case ALLEGRO_KEY_ENTER:
               if(arquivoAberto == true) {
					if(gravaImagem(janela, tipo, altura, largura, maxCor, data)==-1) {
						printf("Erro ao salvar imagem!\n");
						break;
					}
				}
				else {
					printf("Nenhum arquivo aberto!\n");			
				}
               break;
 
            case ALLEGRO_KEY_SPACE:
                 data = rotacao(data, &altura, &largura, 'D');
                 desenha(janela, data, altura, largura);
  
            break;

         }
		
            default:
			break;
			
		}
		
		al_set_target_bitmap(botao_gravar);
        al_set_target_bitmap(botao_carregar);
        al_set_target_bitmap(botao_girar_horario);
        al_set_target_bitmap(botao_girar_antihorario);
    
        al_set_target_bitmap(al_get_backbuffer(janela));
        al_draw_bitmap(botao_carregar, 0,0, 0);
        al_draw_bitmap(botao_gravar, 71,0, 0);
        al_draw_bitmap(botao_girar_horario, 141,0, 0);
        al_draw_bitmap(botao_girar_antihorario, 211,0, 0);
    
    	/*atualiza tela*/
        al_flip_display();
	}

	/*limpeza*/
	if(data!=NULL && arquivoAberto == true){
		desalocaMatriz(data, altura);
	}
    al_destroy_event_queue(filaEvento);
	al_uninstall_mouse();
    al_uninstall_keyboard();
    al_destroy_bitmap(botao_carregar);
    al_destroy_bitmap(botao_gravar);
    al_destroy_bitmap(botao_girar_horario);
    al_destroy_bitmap(botao_girar_antihorario);
	al_destroy_display(janela);

    return 0;
}
示例#14
0
文件: main.c 项目: lucasmoreira/USP
int main() {
	int m[MAXLINHA][MAXCOLUNA], linhas, colunas, maiorValor;
	int c_m[MAXLINHA][MAXCOLUNA], c_linhas, c_colunas, c_maiorValor;
	char nome_arquivo[MAX_NAME], c_nome_arquivo[MAX_NAME], complemento[MAX_NAME], menu = '9';
	int a, b, c, d, t = 0, index_char;

	printf("Digite o nome do arquivo de entrada: ");
	scanf("%s", nome_arquivo);

	while (le_pgm(nome_arquivo, m, &linhas, &colunas, &maiorValor) == 0) {
		printf("Digite o nome do arquivo de entrada: ");
		scanf("%s", nome_arquivo);
	}

	printf("Arquivo %s.pgm carregado com sucesso.\n", nome_arquivo);
	imprime_menu();


	while(menu != 's') {
		if (menu == 'c') {
			printf("Digite o nome do arquivo de entrada: ");
			scanf("%s", nome_arquivo);

			if (le_pgm(nome_arquivo, m, &linhas, &colunas, &maiorValor) == 1) {
				t = 0;

				printf("Arquivo %s.pgm carregado com sucesso.\n\n", nome_arquivo);

			} else return 0;


		} else if (menu == 'a') {
			imprime_menu();
		

		} else if (menu == 't') {
			imprime_matriz(m, linhas, colunas);


		} else if (menu == 'n') {
			negativo(m, linhas, colunas);
			complemento[t++] = 'n';
			printf("Operacao realizada com sucesso.\n");

		} else if (menu == 'r') {
			rotacao(m, &linhas, &colunas);
			complemento[t++] = 'r';
			printf("Operacao realizada com sucesso.\n");

		} else if (menu == 'v') {
			rebatimentoVertical(m, linhas, colunas);
			complemento[t++] = 'v';
			printf("Operacao realizada com sucesso.\n");


		} else if (menu == 'h') {
			rebatimentoHorizontal(m, linhas, colunas);
			complemento[t++] = 'h';
			printf("Operacao realizada com sucesso.\n");


		} else if (menu == 'x') {
			printf("Informe x superior: ");
			scanf("%d", &a);

			printf("Informe y superior: ");
			scanf("%d", &b);

			printf("Informe x inferior: ");
			scanf("%d", &c);

			printf("Informe y inferior: ");
			scanf("%d", &d);

			if (a < 0 || b < 0 || c > (linhas - 1) || d > (colunas - 1) || a > c || b > d) {
				printf("Limites invalidos\n\n");

			} else {
				corte(m, &linhas, &colunas, a, b, c, d);
				complemento[t++] = 'x';
				printf("Operacao realizada com sucesso.\n");

			}



		} else if (menu == 'e') {
			printf("Digite o tamanho da janela: ");
			scanf("%d", &a);

			while(a < 3 || a > 50) {
				printf("Tamanho invalido. A janela deve ser entre 3 e 50.\n");
				printf("Digite o tamanho da janela: ");
				scanf("%d", &a);
			}

			filtroErosao(m, linhas, colunas, a);
			complemento[t++] = 'e';
			printf("Operacao realizada com sucesso.\n");


		} else if (menu == 'd') {
			printf("Digite o tamanho da janela: ");
			scanf("%d", &a);

			while(a < 3 || a > 50) {
				printf("Tamanho invalido. A janela deve ser entre 3 e 50.\n");
				printf("Digite o tamanho da janela: ");
				scanf("%d", &a);
			}

			filtroDilatacao(m, linhas, colunas, a);
			complemento[t++] = 'd';
			printf("Operacao realizada com sucesso.\n");


		} else if (menu == 'm') {
			printf("Digite o tamanho da janela: ");
			scanf("%d", &a);

			while(a < 3 || a > 50) {
				printf("Tamanho invalido. A janela deve ser entre 3 e 50.\n");
				printf("Digite o tamanho da janela: ");
				scanf("%d", &a);
			}

			filtroMediana(m, linhas, colunas, a);
			complemento[t++] = 'm';
			printf("Operacao realizada com sucesso.\n");


		} else if (menu == 'z') {
			printf("Digite o tamanho da janela: ");
			scanf("%d", &a);

			while(a < 3 || a > 50) {
				printf("Tamanho invalido. A janela deve ser entre 3 e 50.\n");
				printf("Digite o tamanho da janela: ");
				scanf("%d", &a);
			}

			filtroMedia(m, linhas, colunas, a);
			complemento[t++] = 'z';
			printf("Operacao realizada com sucesso.\n");


		} else if (menu == '1') {
			printf("Digite o tamanho da janela: ");
			scanf("%d", &a);

			while(a < 3 || a > 50) {
				printf("Tamanho invalido. A janela deve ser entre 3 e 50.\n");
				printf("Digite o tamanho da janela: ");
				scanf("%d", &a);
			}

			printf("Informe o valor de k: ");
			scanf("%d", &b);

			filtroBorda1(m, linhas, colunas, a, b);
			complemento[t++] = '1';
			printf("Operacao realizada com sucesso.\n");


		} else if (menu == '2') {
			printf("Digite o tamanho da janela: ");
			scanf("%d", &a);

			while(a < 3 || a > 50) {
				printf("Tamanho invalido. A janela deve ser entre 3 e 50.\n");
				printf("Digite o tamanho da janela: ");
				scanf("%d", &a);
			}

			printf("Informe o valor de k: ");
			scanf("%d", &b);

			filtroBorda2(m, linhas, colunas, a, b);
			complemento[t++] = '2';
			printf("Operacao realizada com sucesso.\n");


		} else if (menu == '3') {
			printf("Digite o tamanho da janela: ");
			scanf("%d", &a);

			while(a < 3 || a > 50) {
				printf("Tamanho invalido. A janela deve ser entre 3 e 50.\n");
				printf("Digite o tamanho da janela: ");
				scanf("%d", &a);
			}

			printf("Informe o valor de k: ");
			scanf("%d", &b);

			filtroBorda3(m, linhas, colunas, a, b);
			complemento[t++] = '3';
			printf("Operacao realizada com sucesso.\n");


		} else if (menu == 'g') {
			for(index_char = 0; nome_arquivo[index_char] != 0; index_char++) {
				c_nome_arquivo[index_char] = nome_arquivo[index_char];
			}

			if (t > 0)
				c_nome_arquivo[index_char++] = '-';

			for(a = 0; a < t; a++)
				c_nome_arquivo[index_char++] = complemento[a];

			while(c_nome_arquivo[index_char] != 0)
				c_nome_arquivo[index_char++] = 0;

			grava_pgm(c_nome_arquivo, m, linhas, colunas, maiorValor);
			printf("%s.pgm\nArquivo %s.pgm gravado com sucesso.\n", c_nome_arquivo, c_nome_arquivo);


		} else if (menu == 'C') {
			printf("Digite o nome do arquivo para comparacao: \n");
			scanf("%s", c_nome_arquivo);

			if (le_pgm(c_nome_arquivo, c_m, &c_linhas, &c_colunas, &c_maiorValor) == 1) {
				if (c_linhas != linhas || c_colunas != colunas) {
					printf("As matrizes tem dimensoes diferentes.\n");

				} else {
					/* Compara valor a valor e verifica se é igual ou diferente */
					c = 1;
					for(a = 0; a < linhas; a++) {
						for(b = 0; b < colunas; b++) {
							if (m[a][b] != c_m[a][b]) {
								c = 0;
								break;
							}
						}

						if (c == 0) break;
					}

					if (c == 0) printf("As matrizes tem dimensoes diferentes.\n");
					else printf("As matrizes sao iguais.\n");
				}

			} else {
				printf("Falha ao carregar arquivo %s.pgm de comparacao.\n", c_nome_arquivo);

			}

			
		} else if (menu != '9') {
			printf("Comando invalido\n");

		}

		printf("Digite um comando: ");
		scanf(" %c", &menu);
	}

	

	return 0;
}
示例#15
0
文件: main.c 项目: Drebt/Bixos-2018
void main(int argc, char *argv[]) {
    char prefixo_arquivo_out[MAX_NAME - 4];
    int imagem[MAXLINHA][MAXCOLUNA];
    int linhas, colunas, maiorValor, check, larguraJanela, k, limiteValido = 0;
    const char comandos[] = "nrvhedmz123xctgCas";
    char comando = 0;
    int flag = 0;

    if (argc < 2) {
        printf("Usage: %s <arquivo entrada>\n", argv[0]);
        exit(0);
    }

    if (le_pgm(argv[1], imagem, &linhas, &colunas, &maiorValor)) {
        printf("Arquivo %s.pgm carregado com sucesso.\n", argv[1]);
    } else {
        exit(0);
    }

    strcpy(prefixo_arquivo_out, argv[1]);
    void menu();

    while (comando != 's') {
        printf("Digite um comando: ");
        scanf(" %c", &comando);

        if (!strchr (comandos, comando)) {
            printf("Comando invalido\n");
            continue;
        }

        for (int i = 4; i < 11; i++) {
            if (comando == comandos[i]) {
                larguraJanela = 0;
                while (larguraJanela < JANELA_MIN || larguraJanela > JANELA_MAX) {
                    printf("Digite o tamanho da janela: ");
                    scanf("%d", &larguraJanela);
                    if (larguraJanela < JANELA_MIN || larguraJanela > JANELA_MAX) {
                        printf("Tamanho invalido. A janela deve ser entre %d e %d.\n", JANELA_MIN);
                    }
                }
            }
        }

        if (comando == '1' || comando == '2' || comando == '3') {
            printf("Informe o valor de k: ");
            scanf("%d", &k);
        }

        if (comando = 'n') negativo(imagem, linhas, colunas);
        if (comando = 'r') rotacao(imagem, &linhas, &colunas);
        if (comando = 'v') rebatimentoVertical(imagem, linhas, colunas);
        if (comando = 'h') rebatimentoHorizontal(imagem, linhas, colunas);
        if (comando = 'e') filtroErosao(imagem, linhas, colunas, larguraJanela);
        if (comando = 'd') filtroDilatacao(imagem, linhas, colunas, larguraJanela);
        if (comando = 'm') filtroMediana(imagem, linhas, colunas, larguraJanela);
        if (comando = 'z') filtroMedia(imagem, linhas, colunas, larguraJanela);
        if (comando = '1') filtroBorda1(imagem, linhas, colunas, larguraJanela, k);
        if (comando = '2') filtroBorda2(imagem, linhas, colunas, larguraJanela, k);
        if (comando = '3') filtroBorda3(imagem, linhas, colunas, larguraJanela, k);
        if (comando = 'a') menu();

        if (comando == 'c') {
            check = 0;
            while (!check) {
                printf("Digite o nome do arquivo de entrada: ");
                scanf("%s", argv[1]);
                if ((check = le_pgm(argv[1], imagem, &linhas, &colunas, &maiorValor)))
                    printf("Arquivo %s.pgm carregado com sucesso.\n\n", argv[1]);
            }
            strcpy(prefixo_arquivo_out, argv[1]);
            flag = 0;
        }

        if (comando == 't') {
            imprimeMatriz(imagem, linhas, colunas);
            printf("\n");
        }

        if (comando == 'x') {
            int xsup, ysup, xinf, yinf;
            printf("Informe x superior: ");
            scanf("%d", &xsup);
            printf("Informe y superior: ");
            scanf("%d", &ysup);
            printf("Informe x inferior: ");
            scanf("%d", &xinf);
            printf("Informe y inferior: ");
            scanf("%d", &yinf);
            if (xsup < 0 || ysup < 0 || xinf >= linhas || yinf >= colunas || xsup > xinf || ysup > yinf) limiteValido = 0;
            else limiteValido = 1;
            if (limiteValido) {
                corte(imagem, &linhas, &colunas, xsup, ysup, xinf, yinf);
                if (!flag) {
                    strcat(prefixo_arquivo_out, "-");
                    flag = 1;
                }
                strncat(prefixo_arquivo_out, &comando, 1);
                printf("Operacao realizada com sucesso.\n");
            } else {
                printf("Limites invalidos\n\n");
            }
        }

        if (comando == 'g') {
            grava_pgm(prefixo_arquivo_out, imagem, linhas, colunas, maiorValor);
            printf("%s.pgm\n", prefixo_arquivo_out);
            printf("Arquivo %s.pgm gravado com sucesso.\n", prefixo_arquivo_out);
        }

        if (comando == 'C') {
            int c[MAXLINHA][MAXCOLUNA];
            int linhasC, colunasC, maiorValorC;
            char prefixo_arquivo_c[MAX_NAME - 4];
            posicao erro;
            check = 0;
            while (!check) {
                printf("Digite o nome do arquivo com a imagem a ser comparada: ");
                scanf("%s", prefixo_arquivo_c);
                check = le_pgm(prefixo_arquivo_c, c, &linhasC, &colunasC, &maiorValorC);
            }

            erro = compara(imagem, c, linhas, linhasC, colunas, colunasC);

            if (erro.linha == -2 && erro.coluna == -2) {
                printf("As matrizes sao iguais\n");
            } else if (erro.linha == -1 && erro.coluna == -1) {
                printf("As matrizes tem dimensoes diferentes\n");
            } else {
                printf("As matrizes tem valores diferentes na posicao %d, %d\n", erro.linha, erro.coluna);
            }
        }

        for (int i = 0; i < 11; i++) {
            if (comando == comandos[i]) {
                if (flag == 0) {
                    strcat(prefixo_arquivo_out, "-");
                    flag = 1;
                }
                strncat(prefixo_arquivo_out, &comando, 1);
                printf("Operacao realizada com sucesso.\n");
            }
        }
    }
    return;
}