Mat preProcess(Mat &img){
Mat res = Mat(img.rows, img.cols, CV_8UC1);
blur( img, res, Size( 3, 3 ), Point(-1,-1) );
Mat aux = res.clone();
bilateralFilter ( aux, res, 5, 5*2, 5/2 );
aux = res.clone();
cv::GaussianBlur(aux, res, cv::Size(0, 0), 3);
cv::addWeighted(aux, 1.5, res, -0.5, 0, res);
//Filtro de Wiener
cvWiener2ADP(res, res, 5, 5);
//Binarizacao e Afinamento
threshold(res, res, mediana(res), 255, THRESH_BINARY_INV);
//Esqueletização
thinning(res);
/*namedWindow("Preprocess", CV_WINDOW_AUTOSIZE);
imshow("Preprocess", res);
waitKey(0);*/
return res;
}
void Imagen::acuarela(int k) {
Pixel pixel_negro(0, 0, 0);
Pixel2DContainer nuevo_pixels;
Pixel1DContainer filaNegra(ancho(), pixel_negro);
int iter = 0;
while (iter < alto()) {
nuevo_pixels.push_back(filaNegra);
iter++;
}
int i = 0;
while (i < alto()) {
int j = 0;
while (j < ancho()) {
vector<Pixel> kVec = kVecinos(pixels, i, j, k);
if(kVec.size() == (2 * k - 1) * (2 * k - 1))
nuevo_pixels[i][j] = mediana(kVec);
else nuevo_pixels[i][j] = pixel_negro;
j++;
}
i++;
}
pixels = nuevo_pixels;
}
int main(void) {
unsigned char src[RESOLUCAO][RESOLUCAO][21];
unsigned char baixa[RESOLUCAO][RESOLUCAO][21];
unsigned char alta[RESOLUCAO][RESOLUCAO][21];
unsigned char bin[RESOLUCAO][RESOLUCAO][21];
int i;
char fileName[21] = "ImageIrDA/dataxx.csv";
char fileNameS[22] = "ImageIrDA/ALTASxx.csv";
char fileNameT[22] = "ImageIrDA/BAIXAxx.csv";
for(i=1; i<=20; i++) {
fileName[14] = (i/10) + 0x30; // Itera nos nomes dos arquivos
fileName[15] = (i%10) + 0x30;
imRead(fileName, src, (i-1));
}
showImage(src);
for(i=0; i<20; i++) {
mediana(src, baixa, i, 5);
}
//showImage(baixa);
for(i=0; i<20; i++) {
binariza(baixa, bin, i);
}
//showImage(bin);
for(i=0; i<20; i++) {
laplaciano(bin, alta, i);
}
//showImage(alta);
for(i=1; i<=20; i++) { // Salva arquivos das imagens pré processadas
fileNameT[15] = (i/10) + 0x30; // Itera nos nomes dos arquivos
fileNameT[16] = (i%10) + 0x30;
imWrite(fileNameT, baixa, (i-1));
}
for(i=1; i<=20; i++) { // Salva arquivos das imagens pós processadas
fileNameS[15] = (i/10) + 0x30; // Itera nos nomes dos arquivos
fileNameS[16] = (i%10) + 0x30;
imWrite(fileNameS, alta, (i-1));
}
return 0;
}
int main(int argc, const char **argv){
int posicion;
int numeros[N] = {1, 1, 2, 3, 4, 7};
posicion = mediana();
printf("Mediana: %.2lf\n", numeros[posicion] + 0.5);
return EXIT_SUCCESS;
}
main () {
clrscr();
int a[]={8,7,8,8,2,1};
int f[10]={0};
void promedio (int []);//Prototipo
void mediana (int []);//Prototipo
void moda (int [],int []);//Prototipo
promedio (a);
mediana (a);
moda (f,a);
getch();
}
void quickSort2(int anArray[], int aLeftIndex, int aRightIndex)
{
int theSize = aRightIndex - aLeftIndex + 1;
if (theSize <= 3)
{
m_manualSort(anArray, aLeftIndex, aRightIndex);
}
else
{
int thePivot = mediana(anArray, aLeftIndex, aRightIndex);
int thePartitionIndex = m_partitionIt(anArray, aLeftIndex, aRightIndex, thePivot);
//left part sorting
quickSort(anArray, aLeftIndex, thePartitionIndex - 1);
//right part sorting
quickSort(anArray, thePartitionIndex + 1, aRightIndex);
}
}
int main() {
float *nums;
int i,aux,n = 0;
printf("Ola, voce deseja calcular a media e mediana de quantos numeros?\n");
scanf("%d",&n);
aux = n;
n *= sizeof(*nums);
nums = (float*)malloc(n);
for (i = 0;i < aux;i++) {
printf("Por favor digite o %d numero\n",i+1);
scanf("%f",&*(nums+i));
}
printf("Media: %.2f\nMediana: %.2f\n",media(nums,n),mediana(nums,n));
free(nums);
getche();
return 0;
}
Mat ce(Mat img)
{
int quartil = mediana(img);
Mat aux = img.clone();
for (int i = 0; i < img.rows; i++)
{
for (int j = 0; j < img.cols; j++)
{
//cout << (int)img.at<uchar>(i, j) << " ";
if((int)img.at<uchar>(i, j) < quartil)
{
aux.at<uchar>(i, j) = 0;
}
else
{
aux.at<uchar>(i, j) = 255;
}
}
//cout << endl;
}
return aux;
}
int main() {
bool menu = true;
char pontuacao[100];
char vida[100];
ALLEGRO_COLOR font_color;
ALLEGRO_FONT *font,*font2;
ALLEGRO_AUDIO_STREAM *musica = NULL;
camera *cam = camera_inicializa(0);
if(!cam)
erro("erro na inicializacao da camera\n");
int x = 0, y = 0;
int largura = cam->largura;
int altura = cam->altura;
int fps = 0,tempo = 5;
int ndisco = 9;
if(!al_init())
erro("erro na inicializacao do allegro\n");
if(!al_init_image_addon())
erro("erro na inicializacao do adicional de imagem\n");
al_init_font_addon();
al_init_ttf_addon();
font_color = al_map_rgb(0, 0, 0);
font = al_load_ttf_font("Fontes/Blokletters-Viltstift.ttf", 20, 0);
font2 = al_load_ttf_font("Fontes/Blokletters-Viltstift.ttf", 50, 0);
if(!al_init_primitives_addon())
erro("erro na inicializacao do adicional de primitivas\n");
ALLEGRO_TIMER *timer = al_create_timer(1.0 / FPS);
if(!timer)
erro("erro na criacao do relogio\n");
ALLEGRO_DISPLAY *display = al_create_display(2 * largura,altura);
if(!display)
erro("erro na criacao da janela\n");
ALLEGRO_EVENT_QUEUE *queue = al_create_event_queue();
if(!queue)
erro("erro na criacao da fila\n");
if (!al_install_audio())
{
fprintf(stderr, "Falha ao inicializar áudio.\n");
return false;
}
if (!al_init_acodec_addon())
{
fprintf(stderr, "Falha ao inicializar codecs de áudio.\n");
return false;
}
if (!al_reserve_samples(1))
{
fprintf(stderr, "Falha ao alocar canais de áudio.\n");
return false;
}
musica = al_load_audio_stream("Audio/elementary.ogg", 4, 1024);
if(!musica)
erro("Erro na alocação da musica de fundo\n");
al_attach_audio_stream_to_mixer(musica, al_get_default_mixer());
al_set_audio_stream_playing(musica, true);
al_register_event_source(queue, al_get_timer_event_source(timer));
al_register_event_source(queue, al_get_display_event_source(display));
al_start_timer(timer);
unsigned char ***matriz = camera_aloca_matriz(cam);
ALLEGRO_BITMAP *buffer = al_get_backbuffer(display);
ALLEGRO_BITMAP *fundo = al_load_bitmap("Imagens/Elementary2.png");
if(!fundo)
erro("erro ao carregar Elementary.png");
ALLEGRO_BITMAP *esquerda = al_create_sub_bitmap(buffer, 0, 0, largura, altura);
ALLEGRO_BITMAP *direita = al_create_sub_bitmap(buffer, largura, 0, largura, altura);
/**********/
Disco *discos[9];
bool perdeu = false;
carregarDiscos(discos);
int pontos=0,velo = 1;
int aux1 = 1;
int vidas = 10;
int ultimoDisco = 0;
int distance = 0;
int desenhar = 0;
int terminar = 0;
al_set_target_bitmap(esquerda);
al_draw_bitmap(fundo,0,0,0);
while(1) {
ALLEGRO_EVENT event;
al_wait_for_event(queue, &event);
switch(event.type) {
case ALLEGRO_EVENT_TIMER:
desenhar = 1;
break;
case ALLEGRO_EVENT_DISPLAY_CLOSE:
terminar = 1;
break;
}
if(terminar)
break;
if(desenhar && al_is_event_queue_empty(queue)) {
desenhar = 0;
camera_atualiza(cam);
mediana(cam);
/**********/
al_set_target_bitmap(esquerda);
al_draw_bitmap(fundo,0,0,0);
if(!menu){
while(aux1 <= ndisco){
if(discos[aux1]->status == false){
if(distance > 50 || ultimoDisco==0 ){
printf("%d\n",aux1 );
al_draw_bitmap(discos[aux1]->elemento,discos[aux1]->pos_x,discos[aux1]->pos_y,0);
discos[aux1]->status = true;
distance = 0;
ultimoDisco = aux1;
break;
}else
aux1++;
}else{
discos[aux1]->pos_y+=(10+velo);
al_draw_bitmap(discos[aux1]->elemento,discos[aux1]->pos_x,discos[aux1]->pos_y,0);
aux1++;
}
}
distance = discos[ultimoDisco]->pos_y;
for(aux1 = 1;aux1<ndisco;aux1++){
if(discos[aux1]->pos_x >= x-30 && discos[aux1]->pos_x <= x+30 && discos[aux1]->pos_y >= y-30 && discos[aux1]->pos_y <= y+30){
if(discos[aux1]->tipo == 2){ // Tipo do fogo(Necessario para vencer o jogo)
pontos +=10;
velo += 1;
discos[aux1]->pos_x = rand()%9 * 55;
discos[aux1]->pos_y = 0;
discos[aux1]->status = false;
}else if(discos[aux1]->tipo == 1){ //Tipo da agua(Perde o jogo se destruir esse disco)
discos[aux1]->pos_x = rand()%9 * 55;
discos[aux1]->pos_y = 0;
discos[aux1]->status = false;
al_flip_display();
vidas--;
}else if(discos[aux1]->tipo == 3){//Tipo planta(Aumenta velocidade de queda das peças)
velo *= 2;
discos[aux1]->pos_x = rand()%9 * 55;
discos[aux1]->pos_y = 0;
discos[aux1]->status = false;
}
}else if( discos[aux1]->pos_y > 480){
if(discos[aux1]->tipo == 2){ //Tipo da agua e Planta(Não perde se deixar cair)
discos[aux1]->pos_x = rand()%9 * 55;
discos[aux1]->pos_y = 0;
discos[aux1]->status = false;
al_flip_display();
vidas--;
}else{
discos[aux1]->pos_x = rand()%9 * 55;
discos[aux1]->pos_y = 0;
discos[aux1]->status = false;
}
}
}
aux1 = 1;
sprintf(pontuacao,"PONTUAÇÃO: %d",pontos);
al_draw_text(font, al_map_rgb(255, 255, 255), 50, 5, 0,pontuacao);
sprintf(vida,"VIDAS: %d",vidas);
al_draw_text(font, al_map_rgb(255, 255, 255), 300, 5, 0,vida);
al_flip_display();
}
if(perdeu){
al_draw_text(font2, al_map_rgb(255, 0, 0), 50, 100, 0,"PONTUAÇÃO FINAL");
sprintf(pontuacao,"%d",pontos);
al_draw_text(font2, al_map_rgb(255, 0, 0), 250, 170, 0,pontuacao);
al_flip_display();
al_rest(3);
break;
}
if(vidas == 0){
perdeu = true;
}
if(menu){
if(abrirJogo(x,y,&fps,&tempo,font,font2, font_color)){
fundo = al_load_bitmap("Imagens/galaxia.png");
menu = false;
}
}
cameraRastreia(cam,&x,&y);
al_set_target_bitmap(direita);
camera_copia(cam, cam->quadro, direita);
al_flip_display();
}
}
al_destroy_bitmap(direita);
al_destroy_bitmap(fundo);
al_destroy_bitmap(esquerda);
camera_libera_matriz(cam, matriz);
int fri = 9;
while(fri != 0){
free(discos[fri]);
fri--;
}
al_stop_timer(timer);
al_unregister_event_source(queue, al_get_display_event_source(display));
al_unregister_event_source(queue, al_get_timer_event_source(timer));
al_destroy_event_queue(queue);
al_destroy_display(display);
al_destroy_timer(timer);
al_destroy_audio_stream(musica);
al_shutdown_primitives_addon();
al_shutdown_image_addon();
al_uninstall_system();
camera_finaliza(cam);
return EXIT_SUCCESS;
}
void tests() {
auto feq = [](float a, float b){return (max(a,b)-min(a,b)<0.1);};
cerr << "#open mediana OURO IF FOR" << endl;
cerr << (feq(mediana({0, 1, 2}), 1.0));
cerr << (feq(mediana({0, 9, 3.2, 1}), 2.1));
}
void main(int argc, char **argv) {
FILE *file, *fout, *mask_file; // arquivos de entrada e saída
char line[MAX], header_type[MAX]; // strings
int matrix_width, matrix_height, grayscale, weight, soma, mask_size; // colunas, linhas, escala de cinza, weight da máscara, soma dos elementos
int i, j, w, z, x, y; // contadores e auxiliares
int **array, **output, **mask; // matriz da imagem original, matriz da imagem de saída, matriz da mascara
int c, r = 0; // colunas, linhas
// verifica se os argumentos foram passados corretamente
if (argc != 5 && argc != 4) {
printf(
"Os argumentos foram passados incorretamente. Por favor, consulte a documentação.");
exit(EXIT_FAILURE);
} else {
if (!(file = fopen(argv[1], "r"))) {
printf("Não foi possível abrir a imagem.");
exit(EXIT_FAILURE);
}
if (!(fout = fopen(argv[argc - 1], "w+"))) {
printf("Não foi possível abrir a imagem.");
exit(EXIT_FAILURE);
}
}
// se for utilizado o filtro de média, abre a imagem
if (argc == 4) {
if (!(mask_file = fopen(argv[2], "r"))) {
printf("Não foi possível abrir a máscara.");
exit(EXIT_FAILURE);
}
}
// tipo da imagem: P5 ou P2
get_image_type(file, &header_type);
// tamanho da matrix: col lin
get_matrix_size(file, &matrix_width, &matrix_height);
// maior valor da escala de cinza
get_grayscale(file, &grayscale);
// verifica se o nível de cinza é o permitido
if (grayscale > MAX_GRAYSCALE) {
printf("O valor da escala de cinza é maior do que o permitido.");
exit(EXIT_FAILURE);
}
// escreve o cabeçalho da imagem no arquivo
write_image_header(fout, header_type, matrix_width, matrix_height,
grayscale);
// aloca memória para a imagem de saída
output = (int **) (mallocc(sizeof(int *) * matrix_height));
for (i = 0; i < matrix_height; i++) {
output[i] = (int *) (mallocc(sizeof(int) * matrix_width));
}
// copia o corpo da imagem para a matriz
array = read_matrix_elements(file, matrix_width, matrix_height);
output = read_matrix_elements(file, matrix_width, matrix_height);
// filtro da média
mask_size = get_mask_size(mask_file);
if(argc == 4){
// aloca memória para a imagem de saída
mask = (int **) (mallocc(sizeof(int *) * mask_size));
for (i = 0; i < mask_size; i++) {
mask[i] = (int *) (mallocc(sizeof(int) * mask_size));
}
// passa os elementos do arquivo para uma array
mask = read_matrix_elements(mask_file, mask_size, mask_size);
// verifica se o tamanho da mascara está correto
if ((mask_size % 2 == 0) || mask_size < 3) {
printf("Tamanho da máscara incorreto.");
exit(EXIT_FAILURE);
}
// calcula o weight da máscara
for (i = 0; i < mask_size; i++) {
for (j = 0; j < mask_size; j++) {
weight = weight + mask[i][j];
}
}
// aplica o filtro
media( matrix_height, matrix_width, mask_size, weight, array, output );
} else
mediana(matrix_height, matrix_width, mask_size, array, output);
// grava imagem
write_image_body(fout, matrix_width, matrix_height, output);
// libera a memória alocada
free(array);
free(output);
// fecha o buffer dos arquivos
fclose(file);
fclose(fout);
return;
}
