Beispiel #1
0
void menuSaidaHospedes(Quartos *lstQuartos)
{
    int opcao;
    printf("------------------ REALIZAR CHECKOUT ------------------\n\n");
    printf("1 - Realizar checkout hospede\n");
    printf("0 - Voltar para menu\n\n");
    scanf("%i", &opcao);

    switch(opcao)
    {
        case 0:
        default:
            limpar();
            menuHospedagem(lstQuartos);
            break;

        case 1:
            limpar();
            printf("------------------ REALIZAR CHECKOUT ------------------\n\n");
            lstQuartos = realizarSaida(lstQuartos);
            printf("\n\n");
            system("pause");
            limpar();
            menuHospedagem(lstQuartos);
            break;
    }
}
Beispiel #2
0
int main(){
    int casos,a,j,k,tam,tam1;
    char dieta[28],ref1[28],ref2[28],trash[5];
    scanf("%d", &casos);
    fgets(trash,1,stdin);
    for(a=0;a<casos;a++){
        fgets(dieta,27,stdin);
        limpaenter(dieta);

        tam = strlen(dieta);
        qsort(dieta,strlen(dieta),sizeof(char),comp);


        fgets(ref1,27,stdin);
        limpaenter(ref1);

        compdieta(dieta,ref1);
        tam1 = strlen(ref1);
        qsort(ref1,strlen(ref1),sizeof(char),comp);


        fgets(ref2,27,stdin);
        limpaenter(ref2);

        compdieta(dieta,ref2);
        tam1 = strlen(ref2);


        //printf("aqui\n");
        qsort(ref2,tam1-1,sizeof(char),comp);



        limpar(ref1);
        limpar(ref2);
        limpar(dieta);
        printf("ref1:");
        printdoido(ref1);
        printf("ref2:");
        printdoido(ref2);
        printf("dieta:");
        printdoido(dieta);
        // printf("\n");


    }
    return 0;
}
Beispiel #3
0
//Aqui apenas mostra um menu com as opções de hospedagens
void menuHospedagem(Quartos *lstQuartos)
{
    int opcao;

    printf("------------------- MENU HOSPEDAGEM -------------------\n\n");
    printf("1 - Entrada de hospedes\n");
    printf("2 - Consultar hospedagens\n");
    printf("3 - Consumo hospedes\n");
    printf("4 - Saida de hospedes\n");
    printf("0 - Sair do sistema\n\n");
    //printf("0 - Menu principal\n\n");
    scanf("%i", &opcao);

    switch(opcao)
    {
        case 0:
            limpar();
            //main();
            system("exit");
            break;

        case 1:
            limpar();
            menuEntradaHospedes(lstQuartos);
            break;

        case 2:
            limpar();
            consultarHospedagens(lstQuartos);
            break;

        case 3:
            limpar();
            menuConsumoHospedes(lstQuartos);
            break;

        case 4:
            limpar();
            menuSaidaHospedes(lstQuartos);
            break;
        default:
            main();
            break;
    }
}
Beispiel #4
0
//Função responsável por REALIZAR A HOSPEDAGEM PROPRIAMENTE DITA
Quartos *realizarHospedagem(char tipoQuarto[20])
{
    Quartos *quarto = (Quartos*) malloc(sizeof(Quartos)); //Aqui vai guardar os dados do quarto que vai ser ocupado

    limpar();
    printf("------------ OCUPAR UM QUARTO ---------------\n\n");
    //Aqui na hora de hospedar, exibe o tipo do quarto para o usuario.
    printf("Tipo: %s\n\n", tipoQuarto);

    //Aqui passa o tipo do quarto para o REGISTRO para ser salvo na lista
    strcpy(quarto->tipoQuarto, tipoQuarto);
    
    
    //Aqui limpa o BUFFER
    fflush(stdin);

    /**
        A ESTRUTURA CONDICIONAL ABAIXO SERVE APENAS PARA
        ATRIBUIR O VALOR DO QUARTO NO REGISTRO. ELA COMPARA O TIPO DO QUARTO
        E DEFINE O VALOR DO QUARTO.
    */
    if( strcmp(tipoQuarto, "Simples") == 0 )
        quarto->valorQuarto = 50.00;
    else if( strcmp(tipoQuarto, "Suite") == 0 )
        quarto->valorQuarto = 150.00;
    else
        quarto->valorQuarto = 250.00;


    //Aqui exibe o valor do quarto para o usuário
    printf("Valor do quarto: %.2f\n\n", quarto->valorQuarto);

    //Aqui pede as informações do HOSPEDE para salvar no REGISTRO
    printf("\t------------- DADOS DO HOSPEDE -------------\n\n");

    printf("\tNome do hospede: "); //Pede o nome do HOSPEDE
    scanf("%[^\n]", &quarto->hospede.nome); //lÊ O NOME DO HPSPEDE
    fflush(stdin); //LIMPA BUFFER

    printf("\tHospede CPF: ");
    scanf("%i", &quarto->hospede.cpf);
    fflush(stdin);
  
    printf("\tQuantidade de pessoas: ");
    scanf("%i", &quarto->qtdePessoas);
    
    //Aqui altera o status do quarto para OCUPADO
    quarto->statusQuarto = 2;

    //MENSAGEM DE SALVO COM SUCCESSO
    printf("\n\nDados salvos com sucesso!\n");
    printf("Ocupacao do quarto realizada com sucesso!\n\n");
    printf("Favor liberar a chave!\n\n\n");

    //RETORNA O QUARTO
    return quarto;
}
void main() {
  int op;
  do {
    clrscr();
    printf("MENU - LISTA ENCADEADA\n");
    printf("----------------------\n");
    printf("1. Adicionar\n");
    printf("2. Remover\n");
    printf("3. Listar\n");
    printf("4. Limpar\n");
    printf("5. Sair\n\n");
    printf("Opcao: "); scanf("%d",&op);
    clrscr();
    switch (op) {
      case 1: {
	printf("Digite o dado: ");
	int dado;
	scanf("%d",&dado);
	adiciona(dado);
	break;
      }
      case 2: {
	if (inicio!=NULL) {
	  printf("Removendo... ");
	  apaga();
	  getch();
	}
	break;
      }
      case 3: {
	lista();
        getch();
	break;
      }
      case 4: {
	printf("Limpando...");
	limpar();
	getch();
	break;
      }
    }
  } while (op!=5);
  limpar();
}
Imagem* zoom2x(Imagem* org) {
    int i;
    int j;
    Pixel p, a, b, d, e, c;
    Imagem* nova;

    nova = criar_imagem(org->width * 2, org->height * 2);
    limpar(nova, rgb(255, 255, 255));

    for (i = 0; i < org->height; ++i) {
        for (j = 0; j < org->width; ++j) {
            nova->pixels[i*2][j*2] = org->pixels[i][j];
        }
    }

    for (i = 0; i < org->height; ++i) {
        for (j = 0; j < org->width; ++j) {
            if (j+1 < org->width) {
                a = org->pixels[i][j];
                b = org->pixels[i][j+1];
                p = calculo_media(a, b);
            }

            if (j != 0) {
                nova->pixels[i*2][j*2-1] = p;
            }

            if (i+1 < org->height) {
                a = org->pixels[i][j];
                b = org->pixels[i+1][j];
                p = calculo_media(a, b);
            }

            if (i != 0) {
                nova->pixels[i*2-1][j*2] = p;
            }
        }
    }

    for (i = 0; i < nova->height - 2; i += 2) {
        for (j = 0; j < nova->width - 2; j += 2) {
            a = nova->pixels[i][j+1];
            b = nova->pixels[i+1][j];
            d = nova->pixels[i+1][j+2];
            e = nova->pixels[i+2][j+1];
            c = calculo_media4(&a, &b, &d, &e);
            nova->pixels[i+1][j+1] = c;
        }
    }

    return nova;
}
Beispiel #7
0
// Funções
void main()
{
  int op1;

  do
  {
    // Menu
    op1 = menu();
    switch(op1)
    {
      // 1. Cadastrar
      case 1: cadastrar();
              break;

      // 2. Alterar
      case 2: alterar();
              break;

      // 3. Excluir
      case 3: excluir();
              break;

      // 4. Pesquisar
      case 4: pesquisar();
              break;

      // 5. Carregar banco de dados
      case 5: carregar();
              break;

      // 6. Salvar banco de dados
      case 6: salvar();
              break;

      // 7. Limpar banco de dados
      case 7: limpar();
              break;

      // 8. Sair
      case 8: printf("\n\n\tAte mais!\n");
      		  getch();
              break;

      // Outros
      default: printf("\n\n\tDigite uma opcao valida!\n\t[Pressione qualquer tecla para continuar...]\n");
      	      getch();
               break;
    }
  }
  while (op1!=8);
Beispiel #8
0
//Esta função busca quanto um certo hospede consumiiu
//E adiciona algo mais caso ele queira consumir algo a mais...
void menuConsumoHospedes(Quartos *lstQuartos)
{
    //Eu faço isso para evitar DANOS na lista PRINCIPAL,
    //Essa que é passada por parâmetro...
    Quartos *quartos = lstQuartos;

    int opcao;

    printf("------------------ LOJA DO HOTEL ------------------\n\n");
    printf("1 - Realizar venda\n");
    printf("0 - Voltar para o menu principal\n\n");
    scanf("%i", &opcao);

    switch(opcao)
    {
        case 0:
        default:
            limpar();
            menuHospedagem(lstQuartos);
            break;

        case 1:
            limpar();

            //Esta função abre o menu de comes e bebes do hotel
            //E vende algo para o cliente caso ele queira comprar
            //Como isso vai alterar o registro, entao ela deve retornar toda a lista
            lstQuartos = realizarVenda(lstQuartos);

            printf("\n\n");
            system("pause");
            limpar();
            menuHospedagem(lstQuartos);
            break;
    }
}
Beispiel #9
0
//---------------------------------------------------------------------------
void __fastcall TfrmAddItem::btnAdicionarClick(TObject *Sender)
{
//--------- contadores - counters ------------

int i, j, c, l;

//--------------------------------------------
	frmPrincipal->dtControl->BeginUpdate();

	frmPrincipal->dtSaldo->ReadOnly = false;  // Garante que o valor poderá ser modificado.

	for (j = 0; j < frmPrincipal->dtControl->ColumnCount; j++) {
		for (i = 0; i < frmPrincipal->dtControl->RowCount; i++) {
			if (frmPrincipal->dtControl->Cells[j][i] == "" && j == 0){
				if (ddItemGasto->IsSelected == true){
					frmPrincipal->dtControl->Cells[0][i] = "-";
				}
				else if (ddItemEntrada->IsSelected == true) {
					frmPrincipal->dtControl->Cells[0][i] = "+";
				}
				frmPrincipal->dtControl->Cells[1][i] = edtValor->Text;
				frmPrincipal->dtControl->Cells[2][i] = DateEdit1->Text;
				frmPrincipal->dtControl->Cells[3][i] = edtDesc->Text;
				frmPrincipal->dtControl->Cells[4][i] = edtCom->Text;
				c = j;
				l = i;
				i = frmPrincipal->dtControl->RowCount;
			}
			else {

			}
		}
	}

	frmPrincipal->dtControl->EndUpdate();

	frmPrincipal->dtControl->SelectCell(c,l);
	frmAddItem->Hide();
	limpar();
	j = 0;
	i = 0;
	c = 0;
	l = 0;
}
Beispiel #10
0
Quartos *realizarSaida(Quartos *lstQuartos)
{
    Quartos *quarto; //Aqui vamos colocar o quarto que vai ser excluído.
    Quartos *anterior = NULL;
    Quartos *auxLocalizar = lstQuartos; //Aqui vai ajudar a localizar o quarto anterior
    int opcao;

    quarto = exibirQuartoHospede(lstQuartos);

    //Aqui vamos encontrar o registro anterior a este
    while(auxLocalizar->hospede.cpf != quarto->hospede.cpf)
    {
        anterior = auxLocalizar;
        auxLocalizar = auxLocalizar->prox;
    }

    printf("\n\nConfirma checkout deste hospede?\n\n");
    printf("\t1 - Sim\n");
    printf("\t2 - Nao\n");
    printf("\t0 - Voltar para menu principal\n");
    scanf("%i", &opcao);

    switch(opcao)
    {
        case 1:
            if(anterior == NULL)
                lstQuartos = quarto->prox;
            else
                anterior->prox = quarto->prox;

            free(quarto);
            printf("\n\nHospede retirado com sucesso!\n\n");
            break;

        case 2:
        default:
            limpar();
            menuHospedagem(lstQuartos);
            break;
    }

    return lstQuartos;
}
Imagem* reduzir2x(Imagem* org) {
    int i;
    int j;
    Pixel p, a, b, d, e, c;
    Imagem* nova;

    nova = criar_imagem(org->width / 2, org->height / 2);
    limpar(nova, rgb(255, 255, 255));

    for (i = 0; i < org->height - 2; i += 2) {
        for (j = 0; j < org->width - 2; j += 2) {
            a = org->pixels[i][j];
            b = org->pixels[i][j+1];
            c = org->pixels[i+1][j];
            d = org->pixels[i+1][j+1];
            p = calculo_media4(&a, &b, &c, &d);
            nova->pixels[i/2][j/2] = p;
        }
    }

    return nova;
}
Beispiel #12
0
Lista::~Lista() {
    limpar();
}
Beispiel #13
0
Quartos *realizarVenda(Quartos *lstQuartos)
{
    Quartos *quarto; //Aqui vamos obter os dados do hospede que vai efetuar a compra

    int opcao; //aqui vai armazenar a opcao escolhida no menu
    int qtde; //Aqui armazena a quantidade do produto que a pessoa vai comprar
    int isHospede; //Aqui verifica se a pessoa eh hospede ou nao
    float vlrCompra; //Aqui vai ocorrer a multiplicacao entre a qtde e o valor do produto.

    printf("------------------ REALIZAR VENDA ------------------\n\n");

    //Esta funcao apenas imprime na tela o que o hotel tem para vender
    exibirTabelaProdutos();
    scanf("%i", &opcao);

    switch(opcao)
    {
        case 0:
        default:
            menuHospedagem(lstQuartos);
            break;

        case 1:
            limpar();
            printf("Voce escolheu: Refrigerante (Lata)\n");
            printf("Valor: R$ 2.50\n");
            vlrCompra = efetuarCalculoVenda(2.50);
            quarto = buscarQuartoHospede(lstQuartos);
            quarto->valorQuarto += vlrCompra;
            printf("\n\nCompra contabilizada!\n\n");
            break;

        case 2:
            limpar();
            printf("Voce escolheu: Refrigerante (2L)\n");
            printf("Valor: R$ 5.00\n");
            vlrCompra = efetuarCalculoVenda(5.00);
            quarto = buscarQuartoHospede(lstQuartos);
            quarto->valorQuarto += vlrCompra;
            printf("\n\nCompra contabilizada!\n\n");
            break;

        case 3:
            limpar();
            printf("Voce escolheu: Cafe da manha\n");
            printf("Valor: R$ 8.00\n");

            vlrCompra = efetuarCalculoVenda(8.00);
            quarto = buscarQuartoHospede(lstQuartos);
            quarto->valorQuarto += vlrCompra;

            printf("\n\nCompra contabilizada!\n\n");
            break;

        case 4:
            limpar();
            printf("Voce escolheu: Almoco\n");
            printf("Valor: R$ 10.00\n");

            vlrCompra = efetuarCalculoVenda(10.00);
            quarto = buscarQuartoHospede(lstQuartos);
            quarto->valorQuarto += vlrCompra;

            printf("\n\nCompra contabilizada!\n\n");
            break;

        case 5:
            limpar();
            printf("Voce escolheu: Janta\n");
            printf("Valor: R$ 20.00\n");

            vlrCompra = efetuarCalculoVenda(20.00);
            quarto = buscarQuartoHospede(lstQuartos);
            quarto->valorQuarto += vlrCompra;

            printf("\n\nCompra contabilizada!\n\n");
            break;

        case 6:
            limpar();
            printf("Voce escolheu: Pizza\n");
            printf("Valor: R$ 15.00\n");

            vlrCompra = efetuarCalculoVenda(15.00);
            quarto = buscarQuartoHospede(lstQuartos);
            quarto->valorQuarto += vlrCompra;

            printf("\n\nCompra contabilizada!\n\n");
            break;

        case 7:
            limpar();
            printf("Voce escolheu: Sushi\n");
            printf("Valor: R$ 30.00\n");

            vlrCompra = efetuarCalculoVenda(30.00);
            quarto = buscarQuartoHospede(lstQuartos);
            quarto->valorQuarto += vlrCompra;

            printf("\n\nCompra contabilizada!\n\n");
            break;

        case 8:
            limpar();
            printf("Voce escolheu: Halls\n");
            printf("Valor: R$ 1.00\n");

            vlrCompra = efetuarCalculoVenda(1.00);
            quarto = buscarQuartoHospede(lstQuartos);
            quarto->valorQuarto += vlrCompra;

            printf("\n\nCompra contabilizada!\n\n");
            break;

        case 9:
            limpar();
            printf("Voce escolheu: Sorvete\n");
            printf("Valor: R$ 2.00\n");

            vlrCompra = efetuarCalculoVenda(2.00);
            quarto = buscarQuartoHospede(lstQuartos);
            quarto->valorQuarto += vlrCompra;

            printf("\n\nCompra contabilizada!\n\n");
            break;
    }

    return lstQuartos;
}
Beispiel #14
0
//Aqui é o SUBMENU para CONSULTA DE HOSPEDES e QUARTOS
void consultarHospedagens(Quartos *lstQuartos)
{
    int opcao;
    int opTipo; //Esta variavel serve para armazenar o tipo do quarto escolhido no menu
    char tipo[20]; //Esta variavel vai armazenar o tipo do quarto em caracteres.

    printf("-------------------- CONSULTA DE HOSPEDAGENS --------------------\n\n");
    printf("1 - Buscar por hospede\n");
    printf("2 - Buscar por tipo do quarto\n\n");
    scanf("%i", &opcao);

    switch(opcao)
    {
        case 1:
            limpar();

            //Esta função vai BUSCAR o HOSPEDE na LISTA pelo CPF
            exibirQuartoHospede(lstQuartos);

            //Mostra uma mensagem ao usuário e aguarda ele apertar uma tecla
            printf("\n\nPressione qualquer tecla para voltar ao menu de hospedagens\n\n");
            getchar();

            //Limpa a tela e VOLTA para o MENU inicial passando a listar por parâmetro.
            limpar();
            menuHospedagem(lstQuartos);
            break;

        case 2:
            limpar();
            printf("------------- BUSCAR QUARTOS POR TIPO -------------\n\n");
            printf("1 - Simples\n");
            printf("2 - Suite\n");
            printf("3 - Presidencial\n\n");
            scanf("%i", &opTipo);

            //Aqui converte o NUMERO escolhido no MENU para uma string
            switch(opTipo)
            {
                case 1:
                    strcpy(tipo, "Simples");
                    break;

                case 2:
                    strcpy(tipo, "Suite");
                    break;

                case 3:
                    strcpy(tipo, "Presidencial");
                    break;
            }
            //Aqui BUSCA TODOS OS HOSPEDES que estão em UM TIPO DE QUARTO
            buscarQuartoTipo(lstQuartos, tipo);
            printf("\n\n");
            system("pause");
            limpar();
            menuHospedagem(lstQuartos);
            break;
    }

}
Beispiel #15
0
/**
 * Destrutor que exclui uma lista encadeada.
 *
 * Para isso utiliza o método limpar.
 */
CabecaDeLista::~CabecaDeLista() {
	// TODO Auto-generated destructor stub
	limpar();
}
Beispiel #16
0
//---------------------------------------------------------------------------
void __fastcall TfrmAddItem::btnLimparClick(TObject *Sender)
{
	limpar();
}
Beispiel #17
0
   int main(int argc, char* argv[])
   {
      long    data, x, y, contador, menor_cont, nivel_cinza_inf, nivel_cinza_sup, nivel_mat_decisao;
      char    vetor[1000];
      long    lin, col, num_linhas = 0, Janela, lim_jan;
      long    i,j;
      float   **matDecisao;
      int     **matImagem, **matImagem2;
      float  dado, Media, Variancia, Skewness, Curtosis, DesvioPadrao, Lacunaridade, distancia, menor_dist, dist_ant, menor_dist2, menor_dist3, dist_aux, m_variancia, m_var_lido, fator_k;
      float  MaxMedia, MaxVariancia, MaxSkewness, MinSkewness, MaxCurtosis, soma_Media, Media_Aprendizagem;
      long    menor_cont2, menor_cont3, menor_cont_aux;
      int     soma0, soma255, somadist0, somadist255, iclas, kmed, kvar, kske, kcur, klac, kCorrecaoMedia, knn, FatCorrecao;
      struct    {
         float distancia;
         int  classe;
      } classificacao[15]; 
   
      ini = clock();

      BYTE *ImgIn, ImgOut;
      CDIB DIBIn, DIBOut;
      short int var1;
      struct cell *aux;
      inicializa();
      if (argc < 3) 
	  {
		  printf ("Sintaxe: LIM_KNN ImgIn ImOut MatDecisao.txt m v s c l CorrMedia Knn\n");
		  exit(0);
	  }
	  else printf ("LIM_KNN ImgIn ImOut MatDecisao.txt m v s c l CorrMedia Knn\n");
      printf ("Limiarizando a imagem %s em %s\n",argv[1], argv[2]);
      kmed = atoi(argv[4]);
      kvar = atoi(argv[5]);
      kske = atoi(argv[6]);
      kcur = atoi(argv[7]);
      klac = atoi(argv[8]);
      kCorrecaoMedia = atoi(argv[9]);
      knn = atoi(argv[10]);
      DIBIn .LoadBMPFromFile(argv[1]);
      printf("Definindo altura e largura da imagem k=%d \n", knn);
      x = DIBIn.GetImageWidth();
      y = DIBIn.GetImageHeight();
   
      FILE *fpArqMatDecisao;
      if ((fpArqMatDecisao = fopen(argv[3], "r")) == NULL)
         printf("File Read Error MatDecisao.txt");
   
      while (!feof(fpArqMatDecisao))
      {
         fgets(vetor, 1000, fpArqMatDecisao);
         num_linhas++;
      }
      fclose(fpArqMatDecisao);
      num_linhas = num_linhas - 2; 
      matImagem  = (int **) new (int *[y]);
      matImagem2  = (int **) new (int *[y]);
   
      for (i = 0; i < y; i++)
      {
         matImagem[i] = (int *) new (int [x]);
         matImagem2[i] = (int *) new (int [x]);
      }
      printf("Lendo Aprendizagem\n");
      fpArqMatDecisao = fopen(argv[3], "r");
      fscanf(fpArqMatDecisao, " %d %f %d %d %d", &Janela, &Media_Aprendizagem, &col, &col, &i); /*HEADER os ultimos tres sao desprezados*/ 
              
      if (knn == 1) ler(argv[3]);/*Le o arquivo e Monta o vetor - Versao Luciano*/
      else /*Versao Horacio*/
      {
         matDecisao = (float **) new (float *[num_linhas]);
         for (i = 0; i < num_linhas; i++)
            matDecisao[i] = (float *) new (float [6]); 
      
      
         for (lin = 0; lin < num_linhas; lin++)
         {	
            for (col = 0; col < 6; col++)
            {
               fscanf(fpArqMatDecisao, " %f ", &dado);
               matDecisao[lin][col] = dado;
            }
         }
      
      } 
      fclose(fpArqMatDecisao);
      printf("Matriz de Decisao lida e armazenada\n");
      soma_Media = 0.0;
      ImgIn = DIBIn.GetImageBits();
      for (lin=0;lin<y;lin++)
      {
         for (col=0;col<x;col++)
         {
            matImagem[lin][col]=(int)DIBIn.GetPixelG8(col,lin);
            soma_Media = soma_Media + matImagem[lin][col];
         }
      }
      soma_Media = soma_Media / (x*y);
      printf("Imagem convertida para a matriz\n");

      if (kCorrecaoMedia == 1) 
	  {
       FatCorrecao = (int)(Media_Aprendizagem - soma_Media);

	    for (lin = 0; lin < y; lin++) 
           for (col = 0; col < x; col++)
		   {
		     if ((matImagem[lin][col] + FatCorrecao) > 255) matImagem[lin][col] = 255;
			   else 
		        if ((matImagem[lin][col] + FatCorrecao) < 0) matImagem[lin][col] = 0;
			      else  matImagem[lin][col] = matImagem[lin][col] + FatCorrecao;
		    }
	  }
      
	  /********************************/
      /*Aqui calculam-se valores p/normalizacao */

      MaxVariancia = 0.0;
      MaxSkewness = 0.0;
      MaxCurtosis = 0.0;
      MinSkewness = 99999999999999.9;
	  printf ("Normalizando dados...\n");
	  lim_jan = Janela /2;
      for (lin = lim_jan; lin < y-lim_jan; lin++) 
         for (col = lim_jan; col < x-lim_jan; col++)  
         {
            dado = (float)lin/(float)y;
            printf("Processando %.2f %\r", (dado*100));

            Media = 0.0;
            for (i=lin-lim_jan; i<lin+lim_jan+1; i++)
               for (j=col-lim_jan; j<col+lim_jan+1; j++)
                  Media = Media + (float)matImagem[i][j];
         
            Media = (float) Media / (Janela * Janela);
			if (Media > MaxMedia) MaxMedia = Media;
         
            Variancia = 0.0;
	        Skewness = 0.0;
            Curtosis = 0.0;
	    Lacunaridade = 0.0;
            for (i=lin-lim_jan; i<lin+lim_jan+1; i++)
               for (j=col-lim_jan; j<col+lim_jan+1; j++)
               {
		         Variancia = Variancia + (((float)matImagem[i][j] - Media) * ((float)matImagem[i][j] - Media));
                 Skewness = Skewness + (((float)matImagem[i][j] - Media) * ((float)matImagem[i][j] - Media) * ((float)matImagem[i][j] - Media));
                 Curtosis = Curtosis + (((float)matImagem[i][j] - Media) * ((float)matImagem[i][j] - Media) * ((float)matImagem[i][j] - Media) * ((float)matImagem[i][j] - Media));
		 Lacunaridade = Lacunaridade + (Variancia /((Media + (float)matImagem[i][j]) * (Media + (float)matImagem[i][j])));
               }
         
            Variancia = Variancia / (Janela * Janela);
            if (Variancia > MaxVariancia) MaxVariancia = Variancia;
            if (Variancia == 0.0) DesvioPadrao = 0.000001; 
 	     else DesvioPadrao = (float) sqrt (Variancia);
		 
            Skewness = Skewness / (Janela * Janela * DesvioPadrao * DesvioPadrao * DesvioPadrao);
	    if (Skewness > MaxSkewness) MaxSkewness = Skewness;
            if (Skewness < MinSkewness) MinSkewness = Skewness;
	    Curtosis = Curtosis / (Janela * Janela * DesvioPadrao * DesvioPadrao * DesvioPadrao * DesvioPadrao);
	    if (Curtosis > MaxCurtosis) MaxCurtosis = Curtosis;
	    Lacunaridade = (float) Lacunaridade /(Janela * Janela);
            
         }
      printf ("MaxVariancia %f MinSkewness %f MaxSkewness %f MaxCurtosis %f\n", MaxVariancia, MinSkewness, MaxSkewness, MaxCurtosis); 
      /********************************/
      lim_jan = Janela /2;
      printf("Realizando Buscas na Aprendizagem \n");
      for (lin = lim_jan; lin < y-lim_jan; lin++) 
         for (col = lim_jan; col < x-lim_jan; col++)  
         {
            contador = 0;
            dado = (float)lin/(float)y;
            printf("Processando %.2f %\r", (dado*100));            

            Media = 0.0;
            for (i=lin-lim_jan; i<lin+lim_jan+1; i++)
               for (j=col-lim_jan; j<col+lim_jan+1; j++)
                  Media = Media + (float)matImagem[i][j];
         
            Media = (float) Media / (Janela * Janela);
         
            Variancia = 0.0;
            Skewness = 0.0;
            Curtosis = 0.0;
	    Lacunaridade = 0.0;
            for (i=lin-lim_jan; i<lin+lim_jan+1; i++)
               for (j=col-lim_jan; j<col+lim_jan+1; j++)
               {
		         Variancia = Variancia + (((float)matImagem[i][j] - Media) * ((float)matImagem[i][j] - Media));
                 Skewness = Skewness + (((float)matImagem[i][j] - Media) * ((float)matImagem[i][j] - Media) * ((float)matImagem[i][j] - Media));
                 Curtosis = Curtosis + (((float)matImagem[i][j] - Media) * ((float)matImagem[i][j] - Media) * ((float)matImagem[i][j] - Media) * ((float)matImagem[i][j] - Media));
		 Lacunaridade = Lacunaridade + (Variancia /((Media + (float)matImagem[i][j]) * (Media + (float)matImagem[i][j])));
               }
         
            Variancia = Variancia / (Janela * Janela);
            if (Variancia == 0.0) DesvioPadrao = 0.000001;
 	     else DesvioPadrao = (float) sqrt (Variancia);
            Skewness = Skewness / (Janela * Janela * DesvioPadrao * DesvioPadrao * DesvioPadrao);
	    Curtosis = Curtosis / (Janela * Janela * DesvioPadrao * DesvioPadrao * DesvioPadrao * DesvioPadrao);
	    Lacunaridade = (float) Lacunaridade /(Janela * Janela);

            /* Normalizando valores e verificando as caracteristicas a utilizar*/
            Media = kmed * Media;
            Variancia = kvar * 255 * (Variancia / MaxVariancia);
            Skewness = kske * 255 * ((Skewness - MinSkewness) / (MaxSkewness - MinSkewness));
            Curtosis = kcur * 255 * (Curtosis / MaxCurtosis);
	    Lacunaridade = klac * Lacunaridade;

            if (knn == 1) /*Versao do Luciano*/
            {
               aux=Busca(matImagem[lin][col],Media,Variancia,0,Skewness,Curtosis, Lacunaridade);
            	/*nivel_cinza_inf = tom_cinza->dado;
            	nivel_cinza_sup = tom_cinza->dado;*/
            
               matImagem2[lin][col] = aux->c3;
            } /*Fim versao do Luciano*/
            else /*Versao do Horacio para k>1*/
            {
               while ( (matImagem[lin][col] > (int)matDecisao[contador][0]) && (contador < num_linhas-1) )
                  contador++; //Possiciona-se na primeira linha correta da Matriz de Decisao
               nivel_cinza_inf = matDecisao[contador][0];
               nivel_cinza_sup = matDecisao[contador][0];
            
               if (matImagem[lin][col] != (int)matDecisao[contador][0]) /*Nao é igual*/
               {	   
                  if (contador != 0) 
                  {
                     nivel_cinza_inf = matDecisao[contador-1][0];
                     contador = 0;
                     while ( (nivel_cinza_inf != (int)matDecisao[contador][0]) && (contador < num_linhas-1) )
                        contador++; /*Possiciona-se na primeira linha correta da Matriz de Decisao*/
                  }
                  else nivel_cinza_inf = matDecisao[contador][0];
               }
            
            
               for (iclas=0; iclas<knn; iclas++)
               {
                  classificacao[iclas].distancia =  10000000;
                  classificacao[iclas].classe = -1;
               }
            
               menor_dist = 10000000;
               while ((nivel_cinza_inf <= (int)matDecisao[contador][0]) && (nivel_cinza_sup >= (int)matDecisao[contador][0]) && (contador < num_linhas-1) )
               {
                  distancia = (matImagem[lin][col] - matDecisao[contador][0]) + (kmed * ((Media - matDecisao[contador][1]))) + (kvar * ((Variancia - matDecisao[contador][2]) )) + (kske * ((Skewness - matDecisao[contador][4]))) + (kcur * ((Curtosis - matDecisao[contador][5]) )) + (klac * ((Lacunaridade - matDecisao[contador][6])));
               
                  if (distancia < menor_dist)
                  {
                     for (iclas=(knn-2); iclas > -1; iclas--)
                     {
                        classificacao[iclas+1].distancia = classificacao[iclas].distancia;
                        classificacao[iclas+1].classe = classificacao[iclas].classe;
                     }
                  
                     menor_dist = distancia;
                     classificacao[0].distancia = distancia;
                     classificacao[0].classe = matDecisao[contador][3];
                  
                  }
                  contador++;
               
               } 
            
               soma0=0;
               soma255=0;
               somadist0=0;
               somadist255=0;
               for (iclas=0; iclas<knn; iclas++)
               {
                  if (classificacao[iclas].classe == 0) soma0++;
                  if (classificacao[iclas].classe == 255) soma255++;
               }
            
               if (soma0 > soma255) matImagem2[lin][col] = 0;
               if (soma255 > soma0) matImagem2[lin][col] = 255;
               if (soma0 == soma255) //caso especial K= par;
               {
                  for (iclas=0; iclas<knn; iclas++)
                  {
                     if (classificacao[iclas].classe == 0) somadist0 = somadist0 + classificacao[iclas].distancia;
                     if (classificacao[iclas].classe == 255) somadist255 = somadist255 + classificacao[iclas].distancia;
                  }
                  if (somadist0 < somadist255) matImagem2[lin][col] = 0;
                  else matImagem2[lin][col] = 255;
               }
            
            
            } /*Fim versao do Horacio para k>1			*/		
         
         }
      printf("\nFim das Buscas\n");
      DIBOut.CreateImage(x,y,8);
      for (lin=0;lin<y;lin++)
      {
         for (col=0;col<x;col++)
         {
            DIBOut.SetPixelG8(col,lin,BYTE(matImagem2[lin][col]));
         		/*DIBOut.SetPixelG8(lin,col,BYTE(0));
         		//DIBOut.SetPixelG8(lin,col,BYTE(matImagem2[lin][col]);*/
         }
      }	
      printf("Gravando %s\n",argv[2]);
      DIBOut.SaveBMPFromFile(argv[2]);
      limpar();
      printf("Tempo de execucao (ms): %d\n", (clock() - ini)/1000);
      return 0;
   }
Beispiel #18
0
//Aqui é um SUBMENU para registrar as hospedagens
void menuEntradaHospedes(Quartos *lstQuartos)
{
    int opcao, opcao2, qtdeOcupado = 0;
    char tipoQuarto[20];
    Quartos *atual = lstQuartos; //Aqui recebe o inicio da lista
    Quartos *anterior = NULL; //Aqui vai sempre manter o registro anterior
    Quartos *novoQuarto; //Aqui registra o novo quarto

    limpar();
    printf("--------------------- ENTRADA DE HOSPEDES ---------------------\n\n");

    //Esta função (VOID) vai listar os tipos de quartos. Ex.: Simples, suite etc...
    //Fiz isso para o código ficar mais compreensível
    listarTiposQuartos();

    //Aqui o usuário vai escolher que tipo de quarto ele vai querer...
    scanf("%i", &opcao);

    limpar();
    switch(opcao)
    {
        case 1:
            strcpy(tipoQuarto, "Simples");

            //Aqui calcula a quantidade de quartos do tipo SIMPLES que está ocupada.
            qtdeOcupado = qtdeOcupadoPeloTipo(lstQuartos, tipoQuarto);

            printf("Total de quartos %s livres: %i quarto(s)", tipoQuarto, (MAX_SIMPLES - qtdeOcupado));
            break;

        case 2:
            strcpy(tipoQuarto, "Suite");

            //Aqui calcula a quantidade de quartos do tipo SUITE que está ocupada.
            qtdeOcupado = qtdeOcupadoPeloTipo(lstQuartos, tipoQuarto);

            printf("Total de quartos %s livres: %i quarto(s)", tipoQuarto, (MAX_SUITES - qtdeOcupado));
            break;

        case 3:
            strcpy(tipoQuarto, "Presidencial");

            //Aqui calcula a quantidade de quartos do tipo PRESIDENCIAL que está ocupada.
            qtdeOcupado = qtdeOcupadoPeloTipo(lstQuartos, tipoQuarto);

            printf("Total de quartos %s livres: %i quarto(s)", tipoQuarto, (MAX_PRESIDENCIAL - qtdeOcupado));
            break;

        default:
            printf("Opcao Invalida!\n\n");
            system("pause");
            menuEntradaHospedes(lstQuartos);
    }

    fflush(stdin);

    if(listaVazia(lstQuartos) == 1)
    {
        printf("\n\nO que deseja fazer a seguir?\n\n");
        printf("\t1 - Realizar hospedagem\n");
        printf("\t0 - Voltar para menu principal\n");
        scanf("%i", &opcao2);
    }
    else
    {
        /***
            AS ESTRUTURAS CONDICIONAIS A SEGUIR, SERVEM PARA VERIFICAR SE HÁ VAGAS NO
            HOTEL PARA DETERMINADOS QUARTOS.

            DENTRO DELAS, TEM UM PEQUENO MENU COM OPÇÕES...
        */

        if( (strcmp(tipoQuarto, "Simples")== 0) && (qtdeOcupado >= MAX_SIMPLES))
        {
            printf("\n\nInfelizmente, nao temos quartos simples disponiveis...");
            printf("\n\nO que deseja fazer a seguir?\n\n");
            printf("\t0 - Voltar para menu principal\n");
            scanf("%i", &opcao2);
        }
        else if( (strcmp(tipoQuarto, "Suite") == 0) && (qtdeOcupado >= MAX_SUITES))
        {
            printf("\n\nInfelizmente, nao temos suites disponiveis...");
            printf("\n\nO que deseja fazer a seguir?\n\n");
            printf("\t0 - Voltar para menu principal\n");
            scanf("%i", &opcao2);
        }
        else if( (strcmp(tipoQuarto, "Presidencial") == 0) && (qtdeOcupado >= MAX_PRESIDENCIAL))
        {
            printf("\n\nInfelizmente, nao temos quartos presidenciais disponiveis...");
            printf("\n\nO que deseja fazer a seguir?\n\n");
            printf("\t0 - Voltar para menu principal\n");
            scanf("%i", &opcao2);
        }
        else
        {
            printf("\n\nO que deseja fazer a seguir?\n\n");
            printf("\t1 - Realizar hospedagem\n");
            printf("\t0 - Voltar para menu principal\n");
            scanf("%i", &opcao2);
        }
    }

    printf("\n\n");

    switch(opcao2)
    {
        case 0:
            limpar();
            menuHospedagem(lstQuartos);
            break;

        case 1:
            //Aqui chama o método realizar HOSPEDAGEM e atribui para uma variável do tipo QUARTO
            novoQuarto = realizarHospedagem(tipoQuarto); //Aqui registra o novo quarto

            //Este laço de repetição tenta encontrar o registro anterior
            //As variáveis aqui utilizadas, foram declaradas no inicio desta função
            while(atual != NULL)
            {
                anterior = atual;
                atual = atual->prox;
            }

            if(anterior == NULL)
            {
                //Insere no inicio da lista
                novoQuarto->prox = lstQuartos;
                lstQuartos = novoQuarto;
            }
            else
            {
                //Insere no meio ou no fim da lista
                novoQuarto->prox = anterior->prox;
                anterior->prox = novoQuarto;
            }
            system("pause");
            limpar();
            menuHospedagem(lstQuartos);
            break;

        default:
            printf("Opcao Invalida!\n\n");
            system("pause");
            limpar();
            menuEntradaHospedes(lstQuartos);
            break;
    }
}
void roundrobin(int pid, int cpu, int io){
	 struct reg *atual;
	 atual=inicio;
	 while (atual != NULL){
	 	   
	 	   if(atual->pid < pid->prox)
	 	   
	 
	 
	 







main() {
  int op;
  do {


    printf("MENU - ESCALONADOR DE PROCESSOS\n\n");
    printf("----------------------\n");
    printf("Processos-----\n");
    printf("1. Adicionar\n");
    printf("2. Remover\n");
    printf("3. Listar\n");
    printf("4. Limpar\n\n");
    printf("Escalonadores ------\n");
    printf("5. Round Robin\n\n\n");


    printf("0. Sair\n\n");
    printf("Opcao: "); scanf("%d",&op);

    switch (op) {
      case 1: {
	  
	  int pid, pri, tipo, cpu, io;

	printf("Digite o PID: ");
	scanf("%d",&pid);
	printf("Digite o PRI: ");
	scanf("%d",&pri);

	while((tipo>3)||(tipo<1))
	{
	printf("Digite o TIPO (1-system/2-user/3-batch): ");
	scanf("%d",&tipo);
	}

	printf("Digite o CPU: ");
	scanf("%d",&cpu);
	printf("Digite o I/O: ");
	scanf("%d",&io);

	adiciona(pid, pri, tipo, cpu, io);


	break;
      }
      case 2: {
	if (inicio!=NULL) {
	  printf("Removendo... ");
	  apaga();
	  getch();
	}
	break;
      }
      case 3: {
	lista();
        getch();
	break;
      }
      case 4: {
	printf("Limpando...");
	limpar();
	getch();
	break;
      }
    
    case 5: {
		 
		 roundrobin(pid, cpu, io);
		 
		 getch();
		 break;
		 }
		 
    
	}
    
  } while (op!=0);
  limpar();
}