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;
}
}
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;
}
//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;
}
}
//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;
}
// 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);
//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;
}
}
//---------------------------------------------------------------------------
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;
}
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;
}
Lista::~Lista() {
limpar();
}
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;
}
//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;
}
}
/**
* Destrutor que exclui uma lista encadeada.
*
* Para isso utiliza o método limpar.
*/
CabecaDeLista::~CabecaDeLista() {
// TODO Auto-generated destructor stub
limpar();
}
//---------------------------------------------------------------------------
void __fastcall TfrmAddItem::btnLimparClick(TObject *Sender)
{
limpar();
}
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;
}
//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();
}
