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);
}
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);
}
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();
}
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();
}
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();
}
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();
}
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);
}
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);
}
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();
}
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);
}
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);
}
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;
}
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;
}
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;
}
