Paste Search Dynamic
struct image imag;
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include "pngio.h"
  5. #include "hpgl-reader.h"
  6.  
  7. int min(int a, int b) {
  8.     return a < b ? a : b;
  9. }
  10.  
  11. int max(int a, int b) {
  12.     return a > b ? a : b;
  13. }
  14.  
  15. int clamp(int val) {
  16.     return min(max(val, 0), 255);
  17. }
  18.  
  19. void set_r(int r, struct image *img, int row, int col) {
  20.     if (img == null) {
  21.         return;
  22.     }
  23.  
  24.     img->data[row * img->width * 3 + col * 3] = clamp(r);
  25. }
  26.  
  27. void set_g(int g, struct image *img, int row, int col) {
  28.     if (img == null) {
  29.         return;
  30.     }
  31.  
  32.     img->data[row * img->width * 3 + col * 3 + 1] = clamp(g);
  33. }
  34.  
  35. void set_b(int b, struct image *img, int row, int col) {
  36.     if (img == null) {
  37.         return;
  38.     }
  39.  
  40.     img->data[row * img->width * 3 + col * 3 + 2] = clamp(b);
  41. }
  42.  
  43. void set_a(int a, struct image *img, int row, int col) {
  44.     if (img == null) {
  45.         return;
  46.     }
  47.  
  48.     img->data[row * img->width * 3 + col * 3 + 3] = clamp(a);
  49. }
  50.  
  51. struct image *IN_function(){
  52.     struct image *imag;
  53.     imag=(struct image *)malloc(sizeof(struct image));
  54.     imag->height=2400;
  55.     imag->width=3200;
  56.     int nombre_channels_rgb = 4;
  57.     imag->data=(unsigned char **)malloc(sizeof(unsigned char)*imag->width*imag->height*nombre_channels_rgb);
  58.     /*for (int i=0; i<imag->width; i++){
  59.         imag->data[i]=(unsigned char *)malloc(sizeof(unsigned char)*imag->height);
  60.     }*/
  61.  
  62.     return imag;
  63. }
  64.  
  65. int SP_function(struct hpgl_command *cmd){
  66.     int code_couleur=cmd->parms[0];
  67.     return 0;
  68.     /*
  69.     cf. doc projet prof
  70.     0 -> black
  71.          //convertir le chiffre retourne selon la table du prof en code rgb à vérifier
  72.     */
  73. }
  74.  
  75. int PU_function(struct hpgl_command *cmd, struct image *img){
  76.     int rc;
  77.     rc = write_png("image_generee.png", img);
  78.     if(rc < 0) {
  79.         fprintf(stderr, "Couldn't write %s.\n", "image_generee.png");
  80.         return 1;
  81.     }
  82.     free_image(img);
  83.  
  84. }
  85.  
  86. void afficher_encodage_detecte(char *nom_systeme_encodage, struct hpgl_command *cmd){
  87.     int final_encoding = 0;
  88.  
  89.     final_encoding=cmd->parms[0];
  90.     printf("%s ", nom_systeme_encodage);
  91.     switch(final_encoding){
  92.         case 0:
  93.             printf("ANSI ASCII ");
  94.             break;
  95.         case 1:
  96.             printf("9825 Character Set ");
  97.             break;
  98.         case 2:
  99.             printf("French/German");
  100.             break;
  101.         case 3:
  102.             printf("Scandinavian");
  103.             break;
  104.         case 4:
  105.             printf("Spanish/Latin American");
  106.             break;
  107.         case 6:
  108.             printf("JIS ASCII");
  109.             break;
  110.         case 7:
  111.             printf("ROMAN 8 Extensions \n");
  112.             break;
  113.         case 9:
  114.             printf("ISO IRV \n");
  115.             break;
  116.         case 30:
  117.             printf("ISO Swedish \n");
  118.             break;
  119.         case 31:
  120.             printf("ISO Swedish for Names \n");
  121.             break;
  122.         case 32:
  123.             printf("ISO Norway, Version 1 \n");
  124.             break;
  125.         case 33:
  126.             printf("ISO German \n");
  127.             break;
  128.         case 34:
  129.             printf("ISO French \n");
  130.             break;
  131.         case 35:
  132.             printf("ISO Kingdom \n");
  133.             break;
  134.         case 36:
  135.             printf("ISO Italian \n");
  136.             break;
  137.         case 37:
  138.             printf("ISO Spanish \n");
  139.             break;
  140.         case 38:
  141.             printf("ISO Portuguese \n");
  142.             break;
  143.         case 39:
  144.             printf("ISO Norway, Version 2 \n");
  145.     }
  146. }
  147.  
  148. void CS_function(struct hpgl_command *cmd) {
  149.     char * s = "encodage par défaut";
  150.     afficher_encodage_detecte(s, cmd);
  151. }
  152.  
  153. void CA_function(struct hpgl_command *cmd) {
  154.     char *s="encodage alternatif";
  155.     afficher_encodage_detecte(s, cmd);
  156. }
  157.  
  158. void PD_function(struct hpgl_command *cmd, struct image *img, int *point_courant){
  159.     //1 determiner taille complete image
  160.     // SINON pour chaque commande , etudier les limites et reallouer
  161.     //2 splitter les plages de colorisations, faire une boucle qui itère par pas de 2, bouble va aller jusqu'à nparms, et position courante à parms[i], à chaque tour de boucle la position courante va devenir la position que l'on vient de tracer
  162.     int point_fin_trait[2];
  163.  
  164.     //*******************************************************
  165.     //essai image noir complete pour voir si ca fonctionne
  166.     for(int i=0; i<img->width; i++) {
  167.         for(int j=0; j<img->height;j++){
  168.             set_r(0, img, i, j);
  169.             set_g(0, img, i, j);
  170.             set_b(0, img, i, j);
  171.             set_a(255, img, i, j);
  172.         }
  173.     }
  174.     //*******************************************************
  175.  
  176.     //TESTS DIVERS
  177.     //for(int i=0;i<cmd->nparms;i+=2){
  178.         // récupération des positions du segment à tracer
  179.         //1 er extremite du segment
  180.         //point_fin_trait[0]=cmd->parms[i];
  181.         //point_fin_trait[1]=cmd->parms[i+1];
  182.  
  183.         //tracer la ligne = modifier le struct img, point courant = debut du segment
  184.         /*for(int ligne=point_courant[0];ligne<point_fin_trait[0];ligne++)     {
  185.             for(int colonne=point_courant[1];colonne<point_fin_trait[1];colonne++) {
  186.                 img->data[ligne][colonne]=0;
  187.             }
  188.         }*/
  189.  
  190.         /*int fin_image = (img->width*img->height)-2;
  191.         for(int i=0; i < fin_image;i++){
  192.             img->data[i]='0';
  193.             img->data[i+1]='0';
  194.             img->data[i+2]='0';
  195.         }*/
  196.  
  197.         /*for(int i=0; i<img->width; i++) {
  198.             for(int j=0; j<img->height;j++){
  199.                 if(img->data[i][j]!=0){
  200.                     img->data[i][j]=255;
  201.                 }
  202.             }
  203.         }*/
  204.  
  205.         //2 eme extremite du segment
  206.         //point_courant[0]=point_fin_trait[0];
  207.         //point_courant[1]=point_fin_trait[1];
  208.     //}
  209. }
  210.  
  211.  
  212. int
  213. main(int argc, char **argv) {
  214.     struct hpgl_file *hpf;
  215.     struct image *imgg;
  216.     int current_color;
  217.     int point_courant [2] = {0, 0};
  218.     /*
  219.         if(argc != 2) {
  220.             fprintf(stderr, "Syntax: %s filename\n", argv[0]);
  221.             exit(1);
  222.         }
  223.     */
  224.  
  225.     hpf = hpgl_open("HPGL_Example.hpgl"); // modifié
  226.     if(hpf == null) {
  227.         perror("open");
  228.         exit(1);
  229.     }
  230.  
  231.     while(1) {
  232.         struct hpgl_command *cmd = hpgl_read(hpf);
  233.         if(cmd == null)
  234.             break;
  235.         printf("%c%c", cmd->command[0], cmd->command[1]);
  236.         for(int i = 0; i < cmd->nparms; i++) {
  237.             if(i > 0)
  238.                 printf(",");
  239.             printf("%d", cmd->parms[i]);
  240.         }
  241.  
  242.         printf(";");
  243.  
  244.         if(strcmp(cmd->command, "IN")==0){
  245.             imgg=IN_function(cmd);
  246.         }else if(strcmp(cmd->command, "SP")==0){
  247.             current_color=SP_function(cmd);
  248.         }
  249.         else if(strcmp(cmd->command, "PU")==0){
  250.             PU_function(cmd, imgg);
  251.         }else if(strcmp(cmd->command, "PD")==0){
  252.             PD_function(cmd, imgg, point_courant);
  253.         }else if(strcmp(cmd->command, "CS")==0){
  254.             CS_function(cmd);
  255.         }else if(strcmp(cmd->command, "CA")==0){
  256.             CA_function(cmd);
  257.         }
  258.         hpgl_free_command(cmd);
  259.     }
  260.     printf("\n");
  261.     hpgl_close(hpf);
  262.  
  263.     return 0;
  264. }
  265. // FAIRE FONCTION IN : initialise l'état de la table traçante
  266. //FAIRE FONCTION SP : SELECT PEN ou SET PEN choisit la plume numéro 1, normalement une plume noire
  267. //FONCTION PU : PEN UP qui lève la plume
  268. //FONCTION PU0, 0 qui lève la plume et se positionne aux coordonnées (0,0)
  269. //FONCTION PD100,0,100, 100,0,100,0,0 : PEN DOWN qui baisse la plume puis trace des segments de droite depuis la position courante jusqu'aux points de coordonnées(100,0) puis (100, 100), (0, 100) et revient en (0, 0)
Parsed in 0.038 seconds