Lista circularmente encadeada / polígono / graphic.h...

[R!ck]

:blink:

Olá amigos, estou tendo muita dificuldade num código aqui, pois, é a primeira vez que me deparo com a lista circularmente encadeada e com a biblioteca graphic.

Devo resolver o exercício por meio de estrutura de dados usando c.

Utilizo o dev-c++ v4.9.9.2. o qual não possui a biblioteca que comentei.

Então seguindo essas dicas:...

Instalação da Biblioteca BGI no ambiente Dev C++

O código binário do BGIm e maiores detalhes sobre suas funções e seus desenvolvedores

estão disponíveis em http://www.cs.colorado.edu/%7Emain/cs1300/doc/bgi/bgi.html.

Os arquivos necessários para instalação do BGI no Dev C++ são:

graphics.h (copiar em C:\Dev-Cpp\include)

libbgi.a (copiar em C:\Dev-Cpp\lib)

2.1. Uso de Projetos

Para trabalhar em modo gráfico será necessário utilizar o conceito de Projeto. Um projeto

pode ser considerado como um container que armazena todos os elementos que irão

compor um programa.

2.1.1. Criando um novo projeto.

• Clique no menu "File" e selecione "New", "Project...".

• Escolha "Empty Project" e certifique-se que a opçao "C++ project" está selecionada.

• Escolha um nome para o projeto. Você pode dar qualquer nome válido para um

arquivo. O nome do projeto sera o nome do executável a ser gerado.

• Após escolher o nome, clique "OK".

• O Dev-C++ irá perguntar onde salvar o projeto, escolha um diretório apropriado e

salve o projeto.

2.1.2. Criando ou adicionando arquivos ao projeto.

Você pode criar arquivos fonte em branco, de duas formas:

• Clique no menu "File" e selecione "New Source File" ou

• Clique no menu "Project" e selecione "New File".

2.1.3. Configuração do uso da biblioteca gráfica no projeto.

Criado o projeto, você precisa dizer ao Dev-C++ que este deve utilizar a biblioteca BGIm

(que implementa o BGI para o Dev-C++). Isto é feito através da janela "Project

Options". Abaixo segue um conjunto de passos para realizar a tarefa.

• Clique no menu "Project" e escolha "Project Options"

• Clique na tab “Geral” e selecione “Win32 GUI”

• Clique na tab "Parameters"

• No campo "Linker", digite o seguinte texto (ver figura 1):

-lbgi

-lgdi32

-lcomdlg32

-luuid

-loleaut32

-lole32

...consegui utiliza-la somente criando o projeto.cpp mas, na verdade queria um projeto.c

Sem falar que esse é só o início do problema...

Vejam o exercício.

Considere um polígono, inserido num plano cartesiano, cujos vértices vi

são representados por pares ordenados (xi,Yi):

Podemos representá-lo por uma lista p:[vi,v2,v3,...vn], tal que dois elementos

adjacentes em p representam uma aresta do polígono.

Para representar a aresta vn v1, podemos implementar p como uma lista circularmente

encadeada, pois assim, vn e v1 serão adjacentes. Baseando-se Nestas condições,

crie um tipo de dados que possibilite a manipulação de polígonos, oferecendo

as seguintes operações.

a) criar um polígono vazio.

b] Inserir um novo vértice entre v1 e vn

c) Remover um determinado vértice

d) Calcular o perímetro do polígono

e) Mostrar o polígono

f) Destruir o polígono.

E o código que consegui fazer até agora.

#include<stdio.h>
#include<conio.h>
#include<graphics.h>

struct no
{
   int info;   
   struct no *prox;       
};

typedef struct
{
   struct no *inicio;
}lista;


void init(lista *ls)
{
   ls->inicio=NULL;
}


int empty(lista *ls)
{
   if(ls->inicio==NULL)
      return 1;
   else
      return 0;
}

void insert(lista *ls,int pvalor)
{
   struct no *novo=(struct no*)malloc(sizeof(struct no));
   novo->info=pvalor;   
       if(empty(ls))
       {
           novo->prox=novo;
       }
       else
       {
           struct no *navegador = ls->inicio;
           while(navegador->prox!=ls->inicio)
           {
              navegador=navegador->prox;
           }
           navegador->prox=novo;
           novo->prox=ls->inicio;
       }
       ls->inicio=novo;
}


void exibelista(lista *ls)
{
   struct no *navegador=ls->inicio;
   do
   {
       printf("x: %d \nEndereco: %x \nProx: %x \n",navegador->info,navegador,navegador->prox);          
       navegador=navegador->prox;
       
   }while(navegador!=ls->inicio);
}



int main()
{
int i,num;
   lista ls;
   init(&ls);
   do
   {
      printf("\t Menu \n");
      printf("1 - Criar polígono \n");
      printf("2 - Inserir um novo vértice entre v1 e vn \n");
      printf("3 - Remover um determinado vértice \n");
      printf("4 - Calcular o perímetro do polígono \n");
      printf("5 - Mostrar o polígono \n");
      printf("6 - Destruir o polígono \n");
      printf("7 - sair \n");
      scanf("%d",&num);
      system("cls");
      if(num<1||num>7)
      {
         printf("\n Opção inválida! Tente novamente.\n");
         system("pause");
         system("cls");
      }
      switch(num)
      {
         case 1:
            printf("Atencao! Para sair pressione uma tecla na janela grafica\n");
            system("pause");
            system("cls");
            initwindow(1000,700);            
            moveto(250,400);//v0         //posiciona cursor na posição (250,400)        
            lineto(500,150);//v1         //desenha uma linha de (500,150)
            lineto(750,400);//v2        //desenha uma linha de (750,400)               
            lineto(700,650);//v3        //desenha uma linha de (700,650)
            lineto(300,650);//vv-1      //desenha uma linha de (300,650)
            lineto(250,400);//v         //aponta p começo.
            while(!kbhit());      // espera  até  alguma  tecla se pressiona                        
            closegraph();           
            system("cls");          
         break;
         
         case 2:
         break;
         case 3:
         break;
         case 4:
         break;
         
         case 5:
            initwindow(1000,700);
            while(!kbhit());      // espera  até  alguma  tecla se pressiona
            closegraph();         // fecha janela gráfica
         break;
         
         case 6:
         break;         
      }  
      }while(num!=7);
   system("pause");
}

Como podem ver ainda contem muitos erros.

Não estou conseguindo mesclar a lista com as propriedades da biblioteca. Porque não sei como utilizar dois dados no mesmo no da lista. Para poder definir as coordenadas cartezianas e chegar perto do que a questão exige.

Espero que possam me dar uma luz. Porque esse dragão vai decidir os próximos seis meses da minha vida. rsss

Desde já agradecido. = ]

Editado Novembro 28, 2009 por R!ck

[Mnemonic]

Deixe a parte gráfica pro final. O importante primeiro é representar os tipos de dados.

Primeiro você precisa representar um vértice do poligono.

Como eles estão no plano cartesiano, todos eles terão uma coordenada X e Y, além de estarem ligados sempre a outros dois vértices.

typedef struct tVertice {
    float X;
    float Y;
    struct tVertice *p; //proximo
    struct tVertice *a; //anterior
} vertice;

Um poligono vai ser um conjunto de vértices, então você precisa perguntar ao usuário o número de vértices do poligono dele e a partir daí você cria uma função que vai setando as coordenadas X e Y e ligando os ponteiros entre os vértices que for criando, de modo que o *a de um seja igual ao *p de outro. E no final você liga o *p do último com o *a do primeiro.

Depois disso vai ficar mais fácil pra usar as funções da graphics.h, porque basta percorrer a lista e desenhar as coordenadas que você pegou.

[R!ck]

Pow obrigado pela ajuda Mnemonic, mas, pra mim tá muito difícil. = (

Consegui pelo menos usar outra biblioteca, opengl, e deixar o código um pouco melhor.

Só que não consigo mexer direito com a lista. :wacko:

Como está o código atualmente:

#include <windows.h>
#include <GL/gl.h>
#include <GL/glut.h>
#include <stdio.h>
#include <conio.h>

struct no
{
   float x;
   float y;   
   struct no *prox;      
};

typedef struct
{
   struct no *inicio;
}lista;

/*
typedef struct 
    float X;
    float Y;
    struct tVertice *p; //proximo
    struct tVertice *a; //anterior
} vertice;
*/

void inity(lista *ls)
{
   ls->inicio=NULL;
}


int empty(lista *ls)
{
   if(ls->inicio==NULL)
      return 1;
   else
      return 0;
}

void insert(lista *ls,float valorx,float valory)
{
   struct no *novo=(struct no*)malloc(sizeof(struct no));
   novo->x=valorx;
   novo->y=valory;
   
  
      
       if(empty(ls))
       {
           novo->prox=novo;
       }
       else
       {
           struct no *navegador = ls->inicio;
           while(navegador->prox!=ls->inicio)
           {
              navegador=navegador->prox;
           }
           navegador->prox=novo;
           novo->prox=ls->inicio;
       }
       ls->inicio=novo;      
       
       

system("pause");
system("cls");
}


void exibelista(lista *ls)
{
   struct no *navegador=ls->inicio;
   do
   {
       printf("x: %f \nEndereco: %x \nProx: %x \n",navegador->x,navegador,navegador->prox);          
       navegador=navegador->prox;
       printf("y: %f \nEndereco: %x \nProx: %x \n",navegador->y,navegador,navegador->prox);          
       navegador=navegador->prox;
       
       system("pause");
       system("cls");
       
   }while(navegador!=ls->inicio);
}

void display(lista *ls)
{     
 /* Limpa o Buffer de Pixels */
glClear (GL_COLOR_BUFFER_BIT);
// Define a cor padrão como branco
glColor3f (1.0, 1.0, 1.0);
/* desenha um simples retângulo com as coordenadas
* (0.25, 0.25, 0.0) and (0.75, 0.75, 0.0)
*/

glBegin(GL_POLYGON);
glVertex3f( 0.0,0.0,0.0 );
glVertex3f( 0.0,0.0,0.0);
glVertex3f( 0.0,0.0,0.0);
glVertex3f( 0.0,0.0,0.0);
glVertex3f( 0.0,0.0,0.0);
glEnd();

/* Inicia o processo de desenho através dos
dados bufferizados
*/
glFlush ();
}

void init (void)
{
/* Seleciona a cor de fundo para limpeza da tela */
glClearColor (0.0, 0.0, 0.0, 0.0);
/* inicializa os valores de visualização */
glMatrixMode(GL_PROJECTION);
/* Faz com que a matriz corrente seja inicializada com a matriz identidade
(nenhuma transformação é acumulada)
*/
glLoadIdentity();
glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);
}

/*
Cria a janela
*/
int main(int argc, char** argv)
{
int i, num;
float x,y;

lista ls;
inity(&ls);
  
   do
   {
      printf("\t Menu \n");
      printf("1 - Criar um polígono vazio \n");
      printf("2 - Inserir um novo vértice entre v1 e vn \n");
      printf("3 - Remover um determinado vértice \n");
      printf("4 - Calcular o perímetro do polígono \n");
      printf("5 - Mostrar o polígono \n");
      printf("6 - Destruir o polígono \n");
      printf("7 - sair \n");
      scanf("%d",&num);
      system("cls");
      if(num<1||num>7)
      {
         printf("\n Opção inválida! Tente novamente.\n");
         system("pause");
         system("cls");
      }
      switch(num)
      {
         case 1: //Criar um polígono vazio              
            display(&ls);                                          
         break;
         
         case 2://Inserir um novo vértice entre v1 e vn
         
            printf("Informe um valor para a coordenada x:\n");
            scanf("%f",&x);
            printf("Agora informe um valor para a coordenada y:\n");
            scanf("%f",&y);
            
            insert(&ls,x,y);                
         
         break;
         case 3://Remover um determinado vértice
         break;
         case 4://Calcular o perímetro do polígono
         break;
         
         case 5://Mostrar o polígono
              /*
            Estabelece o modo de exibição a ser utilizado pela janela a ser criada
            neste caso utiliza-se de um buffer simples, ou seja, a apresentação será 
            imediata à execução
            Define o modo de cores como RGBA
            */
            glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
            /*
            Determina o tamanho em pixels da
            janela a ser criada
            */
            glutInitWindowSize (800, 600); 
            /*
            Estabelece a posição inicial para criação da
            janela
            */
            glutInitWindowPosition (100, 100);               
            /*
            Cria uma janela com base nos parâmetros especificados
            nas funções glutInitWindowSize e glutInitWindowPosition
            com o nome de título especificado em seu argumento
            */
              glutCreateWindow ("Exemplo 1");                
            
            /*
            Especifica os parâmetros inicias para as variáveis
            de estado do OpenGL
            */
            init ();
            // Associa a função display como uma função de callback
            glutIdleFunc(display);
            /*
            Inicia a execução do programa OpenGL.
            O programa irá executar num loop infinito devendo
            o desenvolvedor especificar as condições de saída do mesmo
            através de interrupções no próprio programa ou através
            de comandos de mouse ou teclado como funções de callback
            */           
              glutMainLoop();
                             
            
         break;
         
         case 6://Destruir o polígono
         break;         
      }  
      }while(num!=7);//sair






   
system("pause");
}

:blink:

Editado Novembro 28, 2009 por R!ck