Projeto ITP 12/11

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

typedef struct pixel_t{
    int r;
    int g;
    int b;
}pixel;

enum comandos {image = 1, color, clear, rect, circle, polygon, fill, save, open};

typedef struct csv_struct{
    int colunas_dados;
    int linhas_dados;
    char dados[40][20][15];

}csv;

typedef struct respostas_t{
    int k;
    struct r_imagem_t{
        int C, L;
    }r_imagem;
    struct r_color_t{
        int r, g, b;
        int col[50];
    }r_color;
    struct r_clear_t{
        int r, g, b;
    }r_clear;
    struct r_rect_t{
        int x, y, base, altura;
    }r_rect;
    struct r_circle_t{
        int x, y, raio;
    }r_circle;
    struct r_line_t{
        int x1, y1, x2, y2;
        int lns[100];
    }r_line;
    struct r_polygon_t{
        int n_pontos;
        int pos[100];
    }r_polygon;
    struct r_fill_t{
        int x;
        int y;
    }r_fill;
    struct r_save_t{
        char nome_arquivo[20];
    }r_save;
    struct r_open_t{
        char nome_arquivo_a_ser_lido[20];
        char nome_arquivo_a_ser_escrito[20];
        char nome_arquivo_anterior[20];
    }r_open;

}respostas;

void Transforma_Matriz_string(FILE *arquivoOrigem, csv *Dados2){
    char StringFormatoCSV[1000] = "";
    char linha[100];
    while(fgets(linha, 100, arquivoOrigem) != NULL){//Transforma todo arquivo escrito em uma única string
        strcat(StringFormatoCSV, linha);
    }

    int cont = 0, i = 0, contador_aux = 0;
    Dados2->colunas_dados = 0;
    Dados2->linhas_dados = 0;
    char auxiliar[100];
    printf("%s\n", StringFormatoCSV);
    while(StringFormatoCSV[i] != '\0'){
        if(StringFormatoCSV[i] != ' ' && StringFormatoCSV[i] != '\n'){
            auxiliar[contador_aux] = StringFormatoCSV[i];
            auxiliar[contador_aux + 1] = '\0';
            contador_aux++;
        }else{
            strcpy(Dados2->dados[Dados2->linhas_dados][Dados2->colunas_dados], auxiliar);
            Dados2->colunas_dados++;
            if(StringFormatoCSV[i] == '\n'){
                Dados2->colunas_dados = 0;
                Dados2->linhas_dados++;
            }
            strcpy(auxiliar, "");
            contador_aux = 0;
        }
        i++;
    }
    strcpy(Dados2->dados[Dados2->linhas_dados][Dados2->colunas_dados], auxiliar);

}

void Captar_comandos_e_variaveis (csv *Dados3, respostas *input){
    int i,linhas = 0, cor = 0;
    for(i = 0; i < Dados3->linhas_dados + 1; i++){

        if(strcmp(Dados3->dados[i][0], "image") == 0 ){
            input->r_imagem.C = atoi(Dados3->dados[i][1]);
            input->r_imagem.L = atoi(Dados3->dados[i][2]);
        }
        if(strcmp(Dados3->dados[i][0], "color") == 0 ){
            input->r_color.r = atoi(Dados3->dados[i][1]);
            input->r_color.g = atoi(Dados3->dados[i][2]);
            input->r_color.b = atoi(Dados3->dados[i][3]);

            input->r_color.col[cor] = input->r_color.r;//Armazena tudo em um vetor
            input->r_color.col[cor+1] = input->r_color.g;
            input->r_color.col[cor+2] = input->r_color.b;

            cor = cor + 3;
        }
        if(strcmp(Dados3->dados[i][0], "clear") == 0 ){
            input->r_clear.r = atoi(Dados3->dados[i][1]);
            input->r_clear.g = atoi(Dados3->dados[i][2]);
            input->r_clear.b = atoi(Dados3->dados[i][3]);
        }
        if(strcmp(Dados3->dados[i][0], "rect") == 0 ){
            input->r_rect.x = atoi(Dados3->dados[i][1]);
            input->r_rect.y = atoi(Dados3->dados[i][2]);
            input->r_rect.base = atoi(Dados3->dados[i][3]);
            input->r_rect.altura = atoi(Dados3->dados[i][4]);
        }
        if(strcmp(Dados3->dados[i][0], "circle") == 0 ){
            input->r_circle.x = atoi(Dados3->dados[i][1]);
            input->r_circle.y = atoi(Dados3->dados[i][2]);
            input->r_circle.raio = atoi(Dados3->dados[i][3]);

        }
        if(strcmp(Dados3->dados[i][0], "line") == 0 ){
            input->r_line.x1 = atoi(Dados3->dados[i][1]);
            input->r_line.y1 = atoi(Dados3->dados[i][2]);
            input->r_line.x2 = atoi(Dados3->dados[i][3]);
            input->r_line.y2 = atoi(Dados3->dados[i][4]);

            input->r_line.lns[linhas] = input->r_line.x1;//Armazena tudo em um vetor
            input->r_line.lns[linhas+1] = input->r_line.y1;
            input->r_line.lns[linhas+2] = input->r_line.x2;
            input->r_line.lns[linhas+3] = input->r_line.y2;

            linhas =linhas + 4;
        }
        if(strcmp(Dados3->dados[i][0], "polygon") == 0 ){

            input->r_polygon.n_pontos = atoi(Dados3->dados[i][1]);
            for (int j = 0; j < 100; ++j){
                input->r_polygon.pos[j] = atoi(Dados3->dados[i][j+2]);
            }
        }
        if(strcmp(Dados3->dados[i][0], "fill") == 0 ){
            input->r_fill.x = atoi(Dados3->dados[i][1]);
            input->r_fill.y = atoi(Dados3->dados[i][2]);
        }
        if(strcmp(Dados3->dados[i][0], "save") == 0 ){
            strcpy(input->r_save.nome_arquivo, Dados3->dados[i][1]);
        }
        if(strcmp(Dados3->dados[i][0], "open") == 0 ){
            strcpy(input->r_open.nome_arquivo_a_ser_lido, Dados3->dados[i][1]);
            strcpy(input->r_open.nome_arquivo_a_ser_escrito, Dados3->dados[i][2]);
            strcpy(input->r_open.nome_arquivo_a_ser_escrito, Dados3->dados[i][3]);
        }
    }
}

void line(int x1, int y1, int x2, int y2, int C, int L, pixel matriz[C][L], int rgb_f[3]){

    int dx = x2 - x1;
    int dy = y2 - y1;
    int step;
    float x, y;

    if(fabs(dx) > fabs(dy)){
        step = fabs(dx);
    }else{
        step = fabs(dy);
    }
    x = x1;
    y = y1;

    float xinc = (float)dx/step;
    float yinc = (float)dy/step;

    for (int i = 0; i <= step; ++i){
        matriz[(int)round(y)][(int)round(x)].r = rgb_f[0];
        matriz[(int)round(y)][(int)round(x)].g = rgb_f[1];
        matriz[(int)round(y)][(int)round(x)].b = rgb_f[2];

        x = x + xinc;
        y = y + yinc;

    }
}
/*
void FuncaoOpen(){//Função está incompleta ainda, mas funciona sozinha em outro código. Precisa adaptar
    FILE *arq1;
    FILE *arq2;
    char Linha1[3];
    int C, L, cor_max;

    //printf("Digite o nome do arquivo a ser lido: ");
    //scanf("%s", nome_arquivo_a_ser_alterado);

    arq1 = fopen("output4.ppm", "r+");
    if(arq1 == NULL){
        printf("Esse arquivo não existe!");
    }

    fscanf(arq1, "%s",Linha1);
    fscanf(arq1, "%d %d", &C, &L);
    fscanf(arq1, "%d", &cor_max);

    pixel matriz[C][L];

    for(int i = 0; i < C; i++){
        for(int j = 0; j < L; j++){
            fscanf(arq1, "%d %d %d ", &matriz[i][j].r, &matriz[i][j].g, &matriz[i][j].b);
        }
    }

    arq2 = fopen("outputOpen2.ppm", "wb");//Faz a escrita no arquivo destino

    fprintf(arq2, "P3\n%d %d\n255\n", L, C);

    for(int i = 0; i < C; i++){//Insere a matriz na imagem
        for(int j = 0; j < L; j++){
            fprintf(arq2, "%d %d %d ", matriz[i][j].r,matriz[i][j].g,matriz[i][j].b);
        }
    }

    fclose(arq1);
    fclose(arq2);
}
 */
void Execucao(csv *Dados3, respostas *input, int c, int l, pixel matriz[c][l], int rgb_f[3]){
    int lin = 0, cr = 0,j = 0;

    for(int i = 0; i < Dados3->linhas_dados + 1; i++){
        if(strcmp(Dados3->dados[i][0], "polygon") == 0 ){
            int aux =0;
            for (int i = 0; i < input->r_polygon.n_pontos-1; i++){
                line(input->r_polygon.pos[aux],input->r_polygon.pos[aux+1],input->r_polygon.pos[aux+2],input->r_polygon.pos[aux+3],input->r_imagem.C,input->r_imagem.L, matriz, rgb_f);
                aux = aux + 2;
            }
        }
        if(strcmp(Dados3->dados[i][0], "line") == 0 ){
            line(input->r_line.lns[lin],input->r_line.lns[lin+1],input->r_line.lns[lin+2],input->r_line.lns[lin+3], input->r_imagem.C, input->r_imagem.L, matriz, rgb_f);

             lin = lin + 4;
        }
        if(strcmp(Dados3->dados[i][0], "color") == 0 ){
            rgb_f[0] = input->r_color.col[cr];
            rgb_f[1] = input->r_color.col[cr+1];
            rgb_f[2] = input->r_color.col[cr+2];

            cr = cr + 3;
        }

        if(strcmp(Dados3->dados[i][0], "save") == 0 ){

            FILE *arquivoDestino = fopen(input->r_save.nome_arquivo, "wb");//Faz a escrita no arquivo destino

            fprintf(arquivoDestino, "P3\n%d %d\n255\n", input->r_imagem.L, input->r_imagem.C);

            for(int i = 0; i < input->r_imagem.C; i++){//Insere a matriz na imagem
                for(int j = 0; j < input->r_imagem.L; j++){
                    fprintf(arquivoDestino, "%d %d %d ", matriz[i][j].r,matriz[i][j].g,matriz[i][j].b);

                }
            }

            fclose(arquivoDestino);
        }

        if(strcmp(Dados3->dados[i][0], "open") == 0 ){
            FILE *arquivoDestino2 = fopen(input->r_open.nome_arquivo_anterior, "wb");//Faz a escrita no arquivo destino

            fprintf(arquivoDestino2, "P3\n%d %d\n255\n", input->r_imagem.L, input->r_imagem.C);

            for(int i = 0; i < input->r_imagem.C; i++){//Insere a matriz na imagem
                for(int j = 0; j < input->r_imagem.L; j++){
                    fprintf(arquivoDestino2, "%d %d %d ", matriz[i][j].r,matriz[i][j].g,matriz[i][j].b);

                }
            }

            fclose(arquivoDestino2);
            //até aqui salva o arquivo anterior com outro nome até chegar no open.

            //FuncaoOpen();
        }

    }
}

int main(){
    respostas resp;
    csv Dados;
    int rgb[3] = {255, 255, 255};//Cor padrão branca

    FILE *arquivoOrigem = fopen("input.txt", "r");
    if(arquivoOrigem == NULL){
        printf("Arquivo não existe!");
        return 0;
    }

    Transforma_Matriz_string(arquivoOrigem, &Dados);//Fatia a string para que se torne uma matriz de strings

    Captar_comandos_e_variaveis(&Dados, &resp);//Faz a leitura dos comandos e capta as variáveis do respectivo comando para utilizar posteriormente

    pixel color[resp.r_imagem.C][resp.r_imagem.L];//Cria a MATRIZ

    for(int i = 0; i < resp.r_imagem.C; i++){
        for(int j = 0; j < resp.r_imagem.L; j++){//Deixa todos os píxels brancos
            color[i][j].r = rgb[0];
            color[i][j].g = rgb[1];
            color[i][j].b = rgb[2];
        }
    }

    Execucao(&Dados,&resp,resp.r_imagem.C,resp.r_imagem.L, color, rgb);

    fclose(arquivoOrigem);

    return 0;
}