C Reproduzir imagem através de código

BifeProgramador · 14 de setembro de 2021

Dei uma atualizada no código, corrigi alguns erros de sintaxe e alguma coisas que tinha colocado errado

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#if defined(_WIN32) || defined(__WIN64__) || defined(__CYGWIN__)
#define VIEW "./i_view32"
#elif defined(__linux__)
#define VIEW "eog"
#endif

typedef int *image;

image alloc_memo(int nl, int nc)
{
    return (image)malloc(nl * nc * sizeof(int));
}

void write_pbm(image img, char *name, int nl, int nc)
{
    FILE *f;
    int i, contador;
    f = fopen (name, "wt");
    if (f==NULL)
    {
        
        puts ("Erro na ao criar arquivo");
        return;
    }
    fputs("P1\n",f);
    fputs("#Olá, bem vindo a atividade6.c\n",f);
    fprintf (f, "%d %d\n", nc , nl);

    contador = 0;
    for (i=0; i < nl * nc; i++)
    {
        fprintf (f, "%d ", img[i]);
        contador++;
        if (contador == 100)
        {
           fprintf (f, "\n");
           contador = 0;
        }
    }

    fclose(f);
}
//Falta fazer
    // 1. gravar os 0's ou 1's da imagem (no máximo 100 valores por linha)

image read_pts(char *name, int *nl, int *nc)
{
    char linha[1000];
    FILE *f;
    int i,j;
    int n;
    image img = NULL;
    
    f = fopen (name, "rt");
    if (f == NULL)
    {
        exit (100);
    }
    fgets (linha,1000,f);
    if (strcmp (linha,"P1"))
        {
            return NULL;
            puts ("não foi possivel abrir");
        }
        fgets (linha,1000,f);
        while (linha[0]=='#')
            fgets (linha,1000,f);

        sscanf (linha,"%d %d",nc,nl);
        img = malloc ((*nl) * (*nc) * sizeof(int));
        for (i=0; i < (*nl) * (*nc); i++)
        {
            fscanf (f, "%d", img + i);
        }

          fclose(f);
          return img;
}
    // Falta fazer
    // 1. preencher o vetor imagem com zeros
    // 2. ler as 'n' coordenadas (i, j) e preencher a posição correspondente de img com 1.
 
  
int main(int argc, char *argv[])
{
    image in;
    char *p;
    char nameIn[40];
    char nameOut[40];
    char command[100];
    int nl, nc;
    if (argc < 2)
    {
        printf("Uso: %s <imagem[.pts]>\n\n", argv[0]);
        return 1;
    }
    if (p = strstr(argv[1], ".pts"))
        *p = 0;
    strcpy(nameIn, argv[1]);
    strcat(nameIn, ".pts");
    strcpy(nameOut, argv[1]);
    strcat(nameOut, ".pbm");

    // transformação
    in = read_pts(nameIn, &nl, &nc);
    write_pbm(in, nameOut, nl, nc);

    sprintf(command, "%s %s &", VIEW, nameOut);
    system(command);
    free(in);
    return 0;
}

42 minutos atrás, arfneto disse:

Um simples loop depois de ler já testa o J: vai ver um J na tela, se fizer como eu disse

Depois de ler o que ?

arfneto · 14 de setembro de 2021

    1	image read_pts(char *name, int *nl, int *nc)
    2	{
    3	    char linha[1000];
    4	    FILE *f;
    5	    int i,j;
    6	    int n;
    7	    image img = NULL;
    8	    
    9	    f = fopen (name, "rt");
   10	    if (f == NULL)
   11	    {
   12	        exit (100);
   13	    }
   14	    fgets (linha,1000,f);
   15	    if (strcmp (linha,"P1"))
   16	        {
   17	            return NULL;
   18	            puts ("nÒo foi possivel abrir");
   19	        }
   20	        fgets (linha,1000,f);
   21	        while (linha[0]=='#')
   22	            fgets (linha,1000,f);
   23	
   24	        sscanf (linha,"%d %d",nc,nl);
   25	        img = malloc ((*nl) * (*nc) * sizeof(int));
   26	        for (i=0; i < (*nl) * (*nc); i++)
   27	        {
   28	            fscanf (f, "%d", img + i);
   29	        }
   30	
   31	          fclose(f);
   32	          return img;
   33	}
   34	    // Falta fazer
   35	    // 1. preencher o vetor imagem com zeros
   36	    // 2. ler as 'n' coordenadas (i, j) e preencher a posiþÒo correspondente de img com 1.
   37

O que está ainda fazendo esse strcmp() na linha 15? Não existe esse indicador na entrada. Eu te expliquei e está no enunciado: Esse é um indicador para aqueles programas mostrarem a imagem. Aqueles que eu te mostrei e que não conheço, mas estão no programa que você recebeu....

Você tem que fazer isso na saída... Apenas na saída.

Porque deixou os items 1 e 2 para o fim? Não acha que ia precisar deles nessa ordem?

Uma quinta oportunidade para eu escrever isso: TESTE o retorno dessas funções.

TODAS elas. fgets() e fscanf() por exemplo. fgets() retorna um ponteiro e é a única maneira de saber se ela leu algo. fscanf() retorna um int e é sua chance de saber quanto do que era para ler foi lido...

Não misture fgets() e fscanf() no mesmo arquivo sem necessidade. É MUITO mais fácil usar fscanf() apenas (nesse caso). Vai ler dados formatados e fscanf() foi escrita para isso, basta ver o nome. o último f é de formatted. e scan é de... scan.

o que é esse modo "rt" na linha 9?

    //////////////////////////////////////////////////////////////////
    // mostra o que leu
    int col = 6;
    pt      = *nc * *nl;
    for (int i = 0; i < pt; i += 1)
    {
        if ( *(img + i) == 1 ) 
            printf("* ");
        else
            printf("  ");
        if (++col % 6 == 0) printf("\n");
    }
    printf("\n");
    //////////////////////////////////////////////////////////////////

Depois de ler, um loop assim por exemplo mostra para o arquivo do exemplo que você postou:

./f0-0913 J
        *
        *
        *
        *
        *
        *
*       *
  * * *

Só um loop. E o que tinha na entrada?

Entende o que eu quero dizer? Antes de seguir em frente espere pra ver se está indo bem. Ao ver o J vai sentir que está no caminho certo...

BifeProgramador · 14 de setembro de 2021

4 minutos atrás, arfneto disse:

O que está ainda fazendo esse strcmp() na linha 15? Não existe esse indicador na entrada. Eu te expliquei e está no enunciado: Esse é um indicador para aqueles programas mostrarem a imagem. Aqueles que eu te mostrei e que não conheço, mas estão no programa que você recebeu....

No enunciado está uma coisa e no código diz para gravar o P1

6 minutos atrás, arfneto disse:

Porque deixou os items 1 e 2 para o fim? Não acha que ia precisar deles nessa ordem?

Deixei porque eu não sei fazer essa parte kkkk

7 minutos atrás, arfneto disse:

o que é esse modo "rt" na linha 9?

leitura

arfneto · 14 de setembro de 2021

3 minutos atrás, BifeProgramador disse:

No enunciado está uma coisa e no código diz para gravar o P1

E? Entende que não está gravando nada? Como vai comparar com algo que não tem lá?

4 minutos atrás, BifeProgramador disse:

No enunciado está uma coisa e no código diz para gravar o P1

Deixei porque eu não sei fazer essa parte kkkk

leitura

Entenda: essa parte é o objetivo do programa. Você não vai ler isso!!!!!!!!!

Eis o que você vai ler, segundo você mesmo:

É isso. A mesma coisa que o J. Só que você postou uma imagem e eu não vou digitar isso tudo. Mas o J é facinho...

E eu não me importei em digitar

Entenda: isso é a saída do programa, não é a entrada. Eu te disse no primeiro post: esta é a entrada:

Você chama isso de J.pts e roda seu programa: ele tem que criar o J.pbm com esse conteúdo. E se rodar esse programa eog ou esse i_view32 vai ver o que te disse para mostrar na tela com esse loop de 6 linhas que te mostrei:

Não existe modo "rt"

3 minutos atrás, arfneto disse:

Deixei porque eu não sei fazer essa parte kkkk

Algo assim serve:

    fprintf( f, "\
P1\n\
# This is an example bitmap of the letter \"J\"\n\
%d %d\n", nl, nc);

Ou assim se achar mais simples de ler

    fprintf( f, "P1\n# This is an example bitmap of the letter \"J\"\n%d %d\n", nl, nc);

BifeProgramador · 14 de setembro de 2021

6 minutos atrás, arfneto disse:

E? Entende que não está gravando nada? Como vai comparar com algo que não tem lá?

Eu entendi o que você quer dizer, primeiro quer q eu faça a função de leitura e rode para ler o J e gerar ele e depois fazer a função que grava . Porém esse trabalho é pra amanhã e essa pressa toda não deixa eu pensar direito e eu só queria terminar logo esse programa

6 minutos atrás, arfneto disse:

Não existe modo "rt"

Então o professor digitou errado quando estava ensinando na aula

arfneto · 14 de setembro de 2021

9 horas atrás, arfneto disse:

Escreva uma função para mostrar na tela a imagem, ou não vai ter como testar. Faça o simples e comece com um quadradinho, ou aquele J do enunciado.

Mantenha o foco e faça passo a passo ou não vai terminar em tempo.

Isso eu te disse no primeiro momento...

Quando tem pressa deve ser ainda mais metódico

Esse era o plano 1, escrevendo em torno dos dados

Como te mostrei pela manhã...

Esse arquivo aí, com os 11 pontinhos. Primeiro lê e mostra, não adianta pensar em gravar se não ler p. nenhuma antes. E precisa ter um mínimo de segurança antes de gravar.

É tudo simples. Mas se atropelar vai levar dias....

image read_pts(char *name, int *nl, int *nc)
{
    // --------------------------------------------
    // Para Fazer
    // 1. abrir o arquivo texto 'nome' para leitura
    // 2. ler o número de linhas e colunas
    // 3. ler o número 'n' de pontos
    // 4. alocar o vetor 'img' com nl x nc
    //    elementos
    // 5. preencher o vetor imagem com zeros
    // 6. ler as 'n' coordenadas (i, j) e preencher
    //    a posição correspondente de img com 1.
    // --------------------------------------------

Você postou isso. Então faça isso. Com controle. Para dar certo da primeira vez

    // 1.
    FILE *f = fopen(name, "r");
    if (f == NULL) return NULL;

não existe modo "rt".

    // 2. ler o número de linhas e colunas
    // 3. ler o número 'n' de pontos

Pois é:

    // 2,3.
    int pt  = 0;  // total de pixels '1'
    int res = fscanf(f, "%d %d %d", nl, nc, &pt);
    if (res != 3) return NULL;  // não leu direito, cancela

Não se preocupe com mensagens de erro e sim com o mais comum: ler e pronto. E use um printf() depois para ficar mais seguro de que está lendo o que acha que está lendo.

E TESTE a p. do resultado de fscanf().

E entenda que se não ler um dos 3 o programa já era de qualquer maneira. Você quer ler o que, no caso do J? 6, 10 e 11. Está lá no arquivo. Então coloca um printf() logo de cara. Vai ver os números certinhos e você apaga. Ou vai uns números enormes ou um crash e você corrige, MAS não segue em frente ou nunca vai terminar.

    // 4. alocar o vetor 'img' com nl x nc
    //    elementos

Não precisa declarar antes e ficar esperando. É uma chance a mais de errar algo. Escreva o simples

    // 4.
    image img = alloc_memo(*nl, *nc);

   // 5. preencher o vetor imagem com zeros

    // 5.
    memset((void *)img, 0, sizeof(int) * (*nl) * (*nc));  // zera tudo

Basta ver o que alocou na tal rotina da linha de cima, certo?

image alloc_memo(int nl, int nc)
{
    return (image)malloc(nl * nc * sizeof(int));
}

Está lá no código que recebeu...

    // 6. ler as 'n' coordenadas (i, j) e preencher
    //    a posição correspondente de img com 1.
    // --------------------------------------------

Pois é. O que vai ler aqui, no caso do J? Os 11 pontos. Acabou de ler esse valor. É só um loop

Vão colocar 1 em 11 pontos e depois mostrar os asteriscos no loop que te mostrei antes... E tanto faz digitar dois por linha ou 4 ou tudo numa linha só: fscanf() só entende uma coisa: espaço em branco. Pula tudo igualzinho, espaços, tabs, newlines, tanto faz. Só não pode ter letrinhas. Por isso é melhor aqui que fgets().

    // 6.
    for (int n = 0, i = 0, j = 0; n < pt; n += 1)
    {  // para os 'pt' pontos
        if (2 != fscanf(f, "%d %d", &i, &j))
        {
            // deu erro:
            free(img);
            return NULL;
        }
        *(img + (i * *nc) + j) = 1;  // marca o pixel
    }

Como te disse, ler todos de 2 em dois é mais fácil. E não é esperto deixar variáveis vivas pelo programa todo se só vai usar aqui, então pode declarar i e j no próprio loop. Se der erro deixa pra lá, retorna NULL. O programa não testa nada mesmo, como pode ver em main().

E copiar os caras é a conta simples que está no enunciado: seus "pixels" estão obviamente um depois do outro em img, como sabe. Foi o que alocou.

Então o pixel (i, j) está em

        *(img + (i * *nc) + j) = 1;  // marca o pixel

E deve estar tudo certo.

Mas para ficar mais seguro... Como te falei da primeira vez:

    //////////////////////////////////////////////////////////////////
    // mostra o que leu
    int col = 6;
    pt      = *nc * *nl;
    for (int i = 0; i < pt; i += 1)
    {
        if ( *(img + i) == 1 ) 
            printf("* ");
        else
            printf("  ");
        if (++col % 6 == 0) printf("\n");
    }
    printf("\n");
    //////////////////////////////////////////////////////////////////

mostra na tela. De 6 em 6. Claro, porque J é 6x10 está no arquivo. A gene só quer saber se está indo no caminho certo. O tal programa depois vai mostrar a imagem de qualquer maneira, ou você pode usar uma imagem simples com uns 1o pontos e contar um por um já que esse modo P1 é texto e você sabe muito bem, porque está no enunciado...

E então ao ver isso na tela

já dá uma sensação de tranquilidade.

Estou mostrando tudo isso porque pode ajudar outros a ver que --- minha opinião --- sempre é mais fácil escrever em torno dos dados e seguir passo a passo. Em geral dá certo da primeira vez, porque esses problemas são simples e buscam mostrar um ou outro conceito por vez...

Eis a função toda:

image read_pts(char *name, int *nl, int *nc)
{
    // --------------------------------------------
    // Para Fazer
    // 1. abrir o arquivo texto 'nome' para leitura
    // 2. ler o número de linhas e colunas
    // 3. ler o número 'n' de pontos
    // 4. alocar o vetor 'img' com nl x nc
    //    elementos
    // 5. preencher o vetor imagem com zeros
    // 6. ler as 'n' coordenadas (i, j) e preencher
    //    a posição correspondente de img com 1.
    // --------------------------------------------

    // 1.
    FILE *f = fopen(name, "r");
    if (f == NULL) return NULL;

    // 2,3.
    int pt  = 0;  // total de pixels '1'
    int res = fscanf(f, "%d %d %d", nl, nc, &pt);
    if (res != 3) return NULL;  // não leu direito, cancela

    // 4.
    image img = alloc_memo(*nl, *nc);

    // 5.
    memset((void *)img, 0, sizeof(int) * (*nl) * (*nc));  // zera tudo

    // 6.
    for (int n = 0, i = 0, j = 0; n < pt; n += 1)
    {  // para os 'pt' pontos
        if (2 != fscanf(f, "%d %d", &i, &j))
        {
            // deu erro:
            free(img);
            return NULL;
        }
        *(img + (i * *nc) + j) = 1;  // marca o pixel
    }

    //////////////////////////////////////////////////////////////////
    // mostra o que leu
    int col = 6;
    pt      = *nc * *nl;
    for (int i = 0; i < pt; i += 1)
    {
        if ( *(img + i) == 1 ) 
            printf("* ");
        else
            printf("  ");
        if (++col % 6 == 0) printf("\n");
    }
    printf("\n");
    //////////////////////////////////////////////////////////////////

    fclose(f);
    return img;
}

Pode estar errado, mas pode muito bem estar certo. Da primeira vez em que rodar.

BifeProgramador · 14 de setembro de 2021

@arfneto Implementei a sua função no meu código e compilou , agora quero saber como faço para testar o J ?

A seguir o código todo para você dar uma olhada

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#if defined(_WIN32) || defined(__WIN64__) || defined(__CYGWIN__)
#define VIEW "./i_view32"
#elif defined(__linux__)
#define VIEW "eog"
#endif

typedef int *image;

image alloc_memo(int nl, int nc)
{
    return (image)malloc(nl * nc * sizeof(int));
}

void write_pbm(image img, char *name, int nl, int nc)
{
    FILE *f;
    int i, contador;
    f = fopen (name, "wt");
    if (f==NULL)
    {
        
        puts ("Erro na ao criar arquivo");
        return;
    }
    fputs("P1\n",f);
    fputs("#Olá, bem vindo a atividade6.c\n",f);
    fprintf (f, "%d %d\n", nc , nl);

    contador = 0;
    for (i=0; i < nl * nc; i++)
    {
        fprintf (f, "%d ", img[i]);
        contador++;
        if (contador == 100)
        {
           fprintf (f, "\n");
           contador = 0;
        }
    }

    fclose(f);
}
//Falta fazer
    // 1. gravar os 0's ou 1's da imagem (no máximo 100 valores por linha)

image read_pts(char *name, int *nl, int *nc)
{
    // --------------------------------------------
    // Para Fazer
    // 1. abrir o arquivo texto 'nome' para leitura
    // 2. ler o número de linhas e colunas
    // 3. ler o número 'n' de pontos
    // 4. alocar o vetor 'img' com nl x nc
    //    elementos
    // 5. preencher o vetor imagem com zeros
    // 6. ler as 'n' coordenadas (i, j) e preencher
    //    a posição correspondente de img com 1.
    // --------------------------------------------

    // 1.
    int i,j,n;
    FILE *f = fopen(name, "r");
    if (f == NULL) return NULL;

    // 2,3.
    int pt  = 0;  // total de pixels '1'
    int res = fscanf(f, "%d %d %d", nl, nc, &pt);
    if (res != 3) return NULL;  // não leu direito, cancela

    // 4.
    image img = alloc_memo(*nl, *nc);

    // 5.
    memset((void *)img, 0, sizeof(int) * (*nl) * (*nc));  // zera tudo

    // 6.
    for (n = 0, i = 0, j = 0; n < pt; n += 1)
    {  // para os 'pt' pontos
        if (2 != fscanf(f, "%d %d", &i, &j))
        {
            // deu erro:
            free(img);
            return NULL;
        }
        *(img + (i * *nc) + j) = 1;  // marca o pixel
    }

    //////////////////////////////////////////////////////////////////
    // mostra o que leu
    int col = 6;
    pt      = *nc * *nl;
    for ( i = 0; i < pt; i += 1)
    {
        if ( *(img + i) == 1 ) 
            printf("* ");
        else
            printf("  ");
        if (++col % 6 == 0) printf("\n");
    }
    printf("\n");
    //////////////////////////////////////////////////////////////////

    fclose(f);
    return img;
}
    // Falta fazer
    // 1. preencher o vetor imagem com zeros
    // 2. ler as 'n' coordenadas (i, j) e preencher a posição correspondente de img com 1.
 
  
int main(int argc, char *argv[])
{
    image in;
    char *p;
    char nameIn[40];
    char nameOut[40];
    char command[100];
    int nl, nc;
    if (argc < 2)
    {
        printf("Uso: %s <imagem[.pts]>\n\n", argv[0]);
        return 1;
    }
    if (p = strstr(argv[1], ".pts"))
        *p = 0;
    strcpy(nameIn, argv[1]);
    strcat(nameIn, ".pts");
    strcpy(nameOut, argv[1]);
    strcat(nameOut, ".pbm");

    // transformação
    in = read_pts(nameIn, &nl, &nc);
    write_pbm(in, nameOut, nl, nc);

    sprintf(command, "%s %s &", VIEW, nameOut);
    system(command);
    free(in);
    return 0;
}

44 minutos atrás, arfneto disse:

E TESTE a p. do resultado de fscanf().

Como faço para testar ?

arfneto · 14 de setembro de 2021

17 minutos atrás, BifeProgramador disse:

Implementei a sua função no meu código e compilou , agora quero saber como faço para testar o J ?

Eu sei que funciona. Eu te mostrei como escrever, é só isso.

Não sei o que dizer sobre como testar....

É estranho você perguntar isso. O programa já não está lá?????

Você entendeu o código? É o programa que você recebeu!!!!!!!!!!!!!!!!!!!! Ele vai chamar a função que eu te expliquei...

se o seu programa se chama pgm para testar isso você escreve

    pgm J

E tecla ENTER....

O que posso dizer? Se o arquivo se chama J.pts, como te mostrei um certo número de vezes desde essa manhã....

Você entendeu o código? Leu? Ou só copiou e apertou uma tecla para compilar?

BifeProgramador · 14 de setembro de 2021

Era pra está funcionando... mas só mostra isso

58 minutos atrás, arfneto disse:

Você entendeu o código? Leu? Ou só copiou e apertou uma tecla para compilar?

Entendi a parte que você editou mas ainda sou um pouco perdido com essa questão de chamar funções, deve ser alguma coisa que não estou percebendo

Ou ele deve precisar do write_pbm completo pra poder executar certo

arfneto · 14 de setembro de 2021

6 minutos atrás, BifeProgramador disse:

Entendi a parte que você editou mas ainda sou um pouco perdido com essa questão de chamar funções, deve ser alguma coisa que não estou percebendo

Acho que não está mesmo.

O programa que recebeu tem as funções e o código que cria o arquivo. É claro que você pode e até deveria ter escrito programas para testar essas coisas em separado, mas não poderia perguntar como testar porque é só rodar o programa e passar o nome de um arquivo de pontos.

E não vou falar de novo sobre o arquivo que te mostrei no PRIMEIRO post dessa série, pela manhã.

Mais ainda: se usa Windows seu próprio programa testa isso, chamando um tal de i_view32 que deve ser um visualizador desse tipo de arquivo bpm, ou o tal eog se usa linux e isso não deveria ser novidade para você porque o programa que recebeu --- um programa ruim --- chama isso automaticamente...

#if defined(_WIN32) || defined(__WIN64__) || defined(__CYGWIN__)
#define VIEW "./i_view32"
#elif defined(__linux__)
#define VIEW "eog"
#endif

E então já sabe como testar

    in = read_pts(nameIn, &nl, &nc);
    write_pbm(in, nameOut, nl, nc);

    sprintf(command, "%s %s &", VIEW, nameOut);
    system(command);

porque está no seu programa.

E também porque eu expliquei isso... p arquivo de saída é texto. Basta usar cat ou type e o nominho dele...

E você mesmo postou um exemplo

BifeProgramador · 14 de setembro de 2021

1 minuto atrás, arfneto disse:

se usa Windows seu próprio programa testa isso, chamando um tal de i_view32

sim ate baixei esse programa aqui na minha máquinha

arfneto · 14 de setembro de 2021

14 minutos atrás, BifeProgramador disse:

Ou ele deve precisar do write_pbm completo pra poder executar certo

É lógico que precisa escrever a função write_pbm() para gravar o arquivo. Uma função que deve ter umas 6 linhas. Abre o arquivo, imprime o cabeçalho e depois em um loop grava os nl*nc pontos

BifeProgramador · 14 de setembro de 2021

agora, arfneto disse:

É lógico que precisa escrever a função write_pbm() para gravar o arquivo. Uma função que deve ter umas 6 linhas. Abre o arquivo, imprime o cabeçalho e depois em um loop grava os nl*nc pontos

No write pbm a unica coisa que fala é isso :

void write_pbm(image img, char *name, int nl, int nc)
{
    FILE *f;
    int i, contador;
    f = fopen (name, "wt");
    if (f==NULL)
    {
        
        puts ("Erro na ao criar arquivo");
        return;
    }
    fputs("P1\n",f);
    fputs("#Olá, bem vindo a atividade6.c\n",f);
    fprintf (f, "%d %d\n", nc , nl);

    contador = 0;
    for (i=0; i < nl * nc; i++)
    {
        fprintf (f, "%d ", img[i]);
        contador++;
        if (contador == 100)
        {
           fprintf (f, "\n");
           contador = 0;
        }
    }

    fclose(f);
}
//Falta fazer
    // 1. gravar os 0's ou 1's da imagem (no máximo 100 valores por linha)

arfneto · 14 de setembro de 2021

agora, BifeProgramador disse:

sim ate baixei esse programa aqui na minha máquinha

é claro, ou o programa que recebeu não vai rodar. Bem, na verdade vai porque ele não testa nada e tem a genial ideia de chamar system() para testar algo...

E nem tenta testar se a chamada deu certo...

BifeProgramador · 14 de setembro de 2021

1 minuto atrás, arfneto disse:

é claro, ou o programa que recebeu não vai rodar. Bem, na verdade vai porque ele não testa nada e tem a genial ideia de chamar system() para testar algo...

E nem tenta testar se a chamada deu certo...

Realmente esse programa que foi dado a gente foi bem confuso... A turma inteira está tendo dificuldades nele

arfneto · 14 de setembro de 2021

5 minutos atrás, BifeProgramador disse:

Realmente esse programa que foi dado a gente foi bem confuso... A turma inteira está tendo dificuldades nele

Ainda está confuso mesmo depois de tudo que eu te expliquei?

Faça uma pergunta ao menos. O que está confuso?

Essa é uma possível função que lê. O que está confuso ainda? Eu te expliquei tudo que estava errado no modo modo estava escrevendo, desde os scanf() a mistura de funções e os erros de lógica.

E te mostrei ao menos duas funções que leem o arquivo...

Você entendeu?

image read_pts(char *name, int *nl, int *nc)
{   // 1.
    FILE *f = fopen(name, "r");
    if (f == NULL) return NULL;
    // 2,3.
    int pt  = 0;  // total de pixels '1'
    int res = fscanf(f, "%d %d %d", nl, nc, &pt);
    if (res != 3) return NULL;  // não leu direito, cancela
    // 4.
    image img = alloc_memo(*nl, *nc);
    // 5.
    memset((void *)img, 0, sizeof(int) * (*nl) * (*nc));  // zera tudo
    // 6.
    for (int n = 0, i = 0, j = 0; n < pt; n += 1)
    {  // para os 'pt' pontos
        if (2 != fscanf(f, "%d %d", &i, &j))
        {   // deu erro:
            free(img);
            return NULL;
        }
        *(img + (i * *nc) + j) = 1;  // marca o pixel
    }
    fclose(f);
    return img;
}

Veja assim

    1	image read_pts(char *name, int *nl, int *nc)
    2	{   // 1.
    3	    FILE *f = fopen(name, "r");
    4	    if (f == NULL) return NULL;
    5	    // 2,3.
    6	    int pt  = 0;  // total de pixels '1'
    7	    int res = fscanf(f, "%d %d %d", nl, nc, &pt);
    8	    if (res != 3) return NULL;  // não leu direito, cancela
    9	    // 4.
   10	    image img = alloc_memo(*nl, *nc);
   11	    // 5.
   12	    memset((void *)img, 0, sizeof(int) * (*nl) * (*nc));  // zera tudo
   13	    // 6.
   14	    for (int n = 0, i = 0, j = 0; n < pt; n += 1)
   15	    {  // para os 'pt' pontos
   16	        if (2 != fscanf(f, "%d %d", &i, &j))
   17	        {   // deu erro:
   18	            free(img);
   19	            return NULL;
   20	        }
   21	        *(img + (i * *nc) + j) = 1;  // marca o pixel
   22	    }
   23	    fclose(f);
   24	    return img;
   25	}

Com números de linha e os comentários apontando para o seu enunciado e os ítens. O que falta eu ---ou seu professor ou alguém --- te explicar sobre isso?

E tem o arquivo e todo o código anterior que eu te mostrei.

O que falta?

E te mostrei umas 5 vezes, desde hoje pela manha, um arquivo de entrada que você deveria usar.

E te expliquei várias coisas que você deveria fazer.

BifeProgramador · 14 de setembro de 2021

5 minutos atrás, arfneto disse:

Faça uma pergunta ao menos. O que está confuso?

Eu não estou sabendo como testar esse J , mesmo com suas explicações ainda não sei fazer. não entendo direito esse código que o professor passou e como ele funciona .

Não sei nem porque ainda insisto nesse curso

vou desistir de entregar esse trabalho

Muito obrigado por sua ajuda e desculpe tomar seu tempo !

arfneto · 14 de setembro de 2021

agora, BifeProgramador disse:

Eu não estou sabendo como testar esse J , mesmo com suas explicações ainda não sei fazer. não entendo direito esse código que o professor passou e como ele funciona .

Não sei nem porque ainda insisto nesse curso

vou desistir de entregar esse trabalho

Muito obrigado por sua ajuda e desculpe tomar seu tempo !

O teste está aqui nessas linhas

    in = read_pts(nameIn, &nl, &nc);
    write_pbm(in, nameOut, nl, nc);

o nome do arquivo você passa quando roda o programa. Vou mostrar ainda uma outra vez: Se você criou um arquivComJ.pts e o seu programa chama pgm.exe vai digitar

    pgm arquivoComJ

E teclar ENTER,

o programa vai chamar read_pts com o nome do arquivo, e vai carregar a imagem.

depois, na linha de baixo, va gravar o arquivo bpm a partir da imagem

E na linha seguinte

    sprintf(command, "%s %s &", VIEW, nameOut);
    system(command);

vai chamar o tal programa que você instalou e mostrar a imagem na tela, o equivalente a aquele loop que eu te mostrei antes.

Você entendeu isso? É só isso. Já está lá. Faça alguma pergunta objetiva.

E gravar o arquivo é uma coisa ingênua

void write_pbm(image img, char *name, int nl, int nc)
{   // 1. criar o arquivo texto 'name'
    FILE *f = fopen(name, "w");
    if (f == NULL) return;
    // 2. gravar o numero mágico 'P1' no arquivo
    // 3. gravar uma linha de comentário '#...'
    // 4. gravar o número de linhas e colunas
    fprintf( f, "\
P1\n\
# arquivo gerado: \"%s\"\n\
%d %d\n", name, nl, nc);
    int col = 0;
    // 5. gravar os 0's ou 1's da imagem
    for (int i = 0; i < nl * nc; i += 1)
    {
        fprintf(f, "%d ", *(img + i));
        if ((++col % 100) == 0) fprintf(f, "\n"); // MAX 100
    }
    fprintf(f, "\n");
    fclose(f);
}

Já está na memória....

    1	void write_pbm(image img, char *name, int nl, int nc)
    2	{   // 1. criar o arquivo texto 'name'
    3	    FILE *f = fopen(name, "w");
    4	    if (f == NULL) return;
    5	    // 2. gravar o numero mßgico 'P1' no arquivo
    6	    // 3. gravar uma linha de comentßrio '#...'
    7	    // 4. gravar o n·mero de linhas e colunas
    8	    fprintf( f, "\
    9	P1\n\
   10	# arquivo gerado: \"%s\"\n\
   11	%d %d\n", name, nl, nc);
   12	    int col = 0;
   13	    // 5. gravar os 0's ou 1's da imagem
   14	    for (int i = 0; i < nl * nc; i += 1)
   15	    {
   16	        fprintf(f, "%d ", *(img + i));
   17	        if ((++col % 100) == 0) fprintf(f, "\n"); // MAX 100
   18	    }
   19	    fprintf(f, "\n");
   20	    fclose(f);
   21	}

Faça alguma pergunta...

Tem os números de linha... O que você não entende? E tem os números das atividades como tinha no código original. Como vê é linear....

Alguma linha dessas você não entende?

Não faça como seu professor: Não use acentos em comentários.

BifeProgramador · 14 de setembro de 2021

36 minutos atrás, arfneto disse:
pgm arquivoComJ

Era isso ! Eu não sabia como chamar o programa

Rodei o exemplo do J , gerou o arquivo pbm e apareceu isso :

Agora sim eu vendo o código rodando inteirinho eu consegui entender melhor como ele funciona

arfneto · 14 de setembro de 2021

7 horas atrás, BifeProgramador disse:

Era isso ! Eu não sabia como chamar o programa

Aparece escrito na tela, e eu te falei umas n vezes...

    if (argc < 2)
    {
        printf("Uso: %s <imagem[.pts]>\n\n", argv[0]);
        return 1;
    }

Se rodar o programa aparece

Uso: pgm <imagem[.pts]>

então NUNCA tinha rodado o programa??

8 horas atrás, BifeProgramador disse:

Agora sim eu vendo o código rodando inteirinho eu consegui entender melhor como ele funciona

É claro que para rodar assim um arquivo pbm você tem que ir no menu do Windows e configurar um programa para abrir esse tipo de arquivo.... Ou do Linux.

BifeProgramador · 14 de setembro de 2021

2 horas atrás, arfneto disse:

então NUNCA tinha rodado o programa??

Tinha só que eu não tava entendendo o que era aquele Uso: %s <imagem[.pts]> depois que eu fui ligar os pontos e fui entender que estava executando da forma errada !

2 horas atrás, arfneto disse:

É claro que para rodar assim um arquivo pbm você tem que ir no menu do Windows e configurar um programa para abrir esse tipo de arquivo.

isso eu ja fiz, configurei pra abrir com i_view 32 e ja me mostrou as imagens, muito obrigado por sua ajuda !

arfneto · 14 de setembro de 2021

5 minutos atrás, BifeProgramador disse:

Tinha só que eu não tava entendendo o que era aquele Uso: %s <imagem[.pts]> depois que eu fui ligar os pontos e fui entender que estava executando da forma errada

Mas de que forma seria errado? Não estava rodando o programa e vendo a mensagem dizendo que o uso correto era fornecer o nome do arquivo com ou sem a extensão pts, como no caso de J.pts?

Se o arquivo for J.txt...

    pgm J.txt

mas se for J.pts pode usar

pgm J

ou

pgm J.pts

Veja essa linha no programa que você postou....

    if (p = strstr(argv[1], ".pts")) *p = 0;

Como eu disse, esse não é um programa assim "bom". Se tinha *.pts no nome então o programa apaga. Isso é uma ideia ruim. Pode ter isso no meio do nome e vai apagar o resto...

BifeProgramador · 14 de setembro de 2021

22 minutos atrás, arfneto disse:

Mas de que forma seria errado? Não estava rodando o programa e vendo a mensagem dizendo que o uso correto era fornecer o nome do arquivo com ou sem a extensão pts, como no caso de J.pts?

Se o arquivo for J.txt...

eu estava executando dessa forma :