C Computação Gráfica com Allegro5

[Midori]

O enunciado,

 

Escreva um programa para desenhar os seguintes segmentos de reta:
 Do ponto (1.0, 6.0) para o ponto (1.0, 1.0)
 Do ponto (1.0, 5.8) para o ponto (1.2, 1.0)
 Do ponto (1.0, 5.6) para o ponto (1.4, 1.0)
 ...
 Do ponto (1.0, 1.0) para o ponto (6.0, 1.0)

 

Para resolver escolhi o Allegro5. Esta é a especificação das funções que devem ser implementadas na lib escolhida (tive que criar duas variáveis globais),

 

move(x, y) posiciona no ponto (x, y)
draw(x, y) desenha um segmento de reta da posição atual para o ponto (x, y)

 

A resolução da minha tela pode variar, mas nesse escolhi 480x480. Acontece que o range desse e de diversos exercícios são: 0 <= x <= 9, 0 <= y <= 7. O problema é que para desenhar as figuras tenho sempre que ajustar as coordenadas, p.ex este é o meu código para esse exercício,

 

#include <allegro5/allegro.h>
#include <allegro5/allegro_primitives.h>

#define LARGURA 480
#define ALTURA  480
#define ESCALA  50

float xP = 0;
float yP = 0;

typedef struct {
    float x;
    float y;
}Ponto;

Ponto* move(Ponto *);
Ponto* draw(Ponto *);
ALLEGRO_DISPLAY* inicia(int largura, int altura);

int main(int argc, char *argv[]) {
    ALLEGRO_KEYBOARD_STATE tecla;
    Ponto A = { 1.0 * ESCALA, 6.0 * ESCALA };
    Ponto B = { 1.0 * ESCALA, 1.0 * ESCALA };

    inicia(LARGURA, ALTURA);

    while (A.y >= 1.0 * ESCALA) {
        move(&A);
        draw(&B);
        A.y -= 0.2 * ESCALA;
        B.x += 0.2 * ESCALA;
    }

    al_flip_display();
    do {
        al_get_keyboard_state(&tecla);
    } while (!al_key_down(&tecla, ALLEGRO_KEY_ESCAPE));
    return 0;
}

Ponto* move(Ponto *ponto) {
    xP = ponto->x;
    yP = ponto->y;
    return ponto;
}

Ponto* draw(Ponto *ponto) {
    al_draw_line(xP, yP, ponto->x, ponto->y, 
            al_map_rgb(0, 200, 200), 1);
    return move(ponto);
}

ALLEGRO_DISPLAY* inicia(int largura, int altura) {
    ALLEGRO_DISPLAY* display = NULL;
    al_init();
    al_install_keyboard();
    al_set_new_display_flags(ALLEGRO_WINDOWED);
    display = al_create_display(largura, altura);
    al_init_primitives_addon();
    return display;
}

 

A figura gerada,

 

Qual seria melhor forma de resolver essa questão da "escala"?

 

Nesse caso coloquei essa constante nas coordenadas, mas não ficou legal e para cada exercício tenho que ficar ajustando isso.

 

Ponto A = { 1.0 * ESCALA, 6.0 * ESCALA };
Ponto B = { 1.0 * ESCALA, 1.0 * ESCALA };

 

Em outro programa eu tive que ajustar assim,

Ponto A = { 2.0 * ESCALA, 0.5 * ESCALA };
Ponto B = { 8.0 * ESCALA, 0.5 * ESCALA };
Ponto C = { 8.0 * ESCALA, 6.5 * ESCALA };
Ponto D = { 2.0 * ESCALA, 6.5 * ESCALA };

 

Já testei a escala dentro das funções draw e move, mas não ficou bom.

 

[arfneto]

45 minutos atrás, Midori disse:

Qual seria melhor forma de resolver essa questão da "escala"?

 

45 minutos atrás, Midori disse:

Já testei a escala dentro das funções draw e move, mas não ficou bom.

 

Para a escala em geral se ajusta em relação ao aspecto, que é a razão da altura / largura em pixels da janela. E se tem um tamanho físico que quer garantir faz um ajuste para considerar a largura do pixel, ou a densidade em pixels por polegada. Acho que para imprimir se usa 72 ppi como resolução normal

 

Mas como seria "bom" ?

[Midori]

1 hora atrás, arfneto disse:

Mas como seria "bom" ?

Em alguns casos a figura nem aparece ou fica cortada (uma parte fora da tela) e tenho que ajustar o valor de ESCALA até ficar enquadrada, tanto na função quanto nas variáveis que modificam as coordenadas no loop. Mas isso que comentou sobre ajustar em relação ao aspecto deve resolver.

 

Ficou assim, só modifiquei a função draw,

Ponto* draw(Ponto* ponto) {
    Ponto A = {
        xP * LARGURA / 9.0,
        yP * ALTURA / 7.0
    };

    Ponto B = {
        ponto->x * LARGURA / 9.0,
        ponto->y * ALTURA / 7.0
    };

    al_draw_line(A.x, A.y, B.x, B.y,
        al_map_rgb(0, 200, 200), 1);
    return move(ponto);
}

 

Dessa forma dá para usar as coordenadas originais dos exercícios para os pontos e não há mais a necessidade daquele define ESCALA.

 

Como ficaria se for considerada a densidade em pixels por polegada?

[arfneto]

@Midori Usar PPI permitira controlar o tamanho da imagem na tela ou no papel em milímetros, só isso.

 

Provavelmente em C seria melhor ter uma abstração da tela e lá dentro os parâmetros, e até onde possível isolar essa abstração da biblioteca em uso.

[Midori]

A última modificação que postei acabou não dando certo, dependendo da largura/altura passada para a função inicia, algumas figuras não ficam na proporção correta como esta que devia ser um quadrado,

 

 

Para resolver achei melhor remover as constantes LARGURA e ALTURA e passei para a função inicia um valor para atribuir um múltiplo de 9 (LARG_ORIG) para a largura e de 7 (ALTR_ORIG) a altura,

unsigned int largura = LARG_ORIG * unidade;
unsigned int altura = ALTR_ORIG * unidade;

 

ALLEGRO_DISPLAY* inicia(unsigned int unidade);

 

E draw ficou assim (dsp é um ALLEGRO_DISPLAY*),

Ponto* draw(Ponto* ponto) {
    Ponto A = {
        xP * al_get_display_width(dsp) / LARG_ORIG,
        yP * al_get_display_height(dsp) / ALTR_ORIG
    };
    Ponto B = {
        ponto->x * al_get_display_width(dsp) / LARG_ORIG,
        ponto->y * al_get_display_height(dsp) / ALTR_ORIG
    };

    al_draw_line(
        A.x, A.y, B.x, B.y, al_map_rgb(0, 200, 200), 1);
    return move(ponto);
}

 

Dessa forma a imagem fica sempre na proporção certa, p.ex,

[arfneto]

@Midori seria a correção pelo aspecto para restaurar a proporção