Paste Search Dynamic
struct image
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4.  
  5. #include "pngio.h"
  6.  
  7. #include "hpgl-reader.h"
  8.  
  9.  
  10.  
  11. struct image *IN_function(){
  12.     struct image *imag;
  13.     imag=(struct image *)malloc(sizeof(struct image *));
  14.     imag->height=500;
  15.     imag->width=500;
  16.     unsigned char **data;
  17.     data=(unsigned char **)malloc(sizeof(char *)*imag->width*imag->height);
  18.     for (int i=0; i<imag->width; i++){
  19.         imag->data[i]=(char *)malloc(sizeof(char)*imag->height);
  20.     }
  21.    
  22.     return imag;
  23. }
  24.  
  25. void SP_function(struct hpgl_command *cmd){
  26.     /*
  27.     cf. doc projet prof
  28.     0 -> black
  29.     .
  30.     .
  31.     .
  32.          >  black
  33.          //convertir le chiffre retourne selon la table du prof en code rgb à vérifier
  34.     */
  35.    
  36. }
  37.  
  38. void PU_function(struct hpgl_command *cmd, struct image *img){
  39.     int rc;
  40.     rc = write_png("image_generee.png", img);
  41.         if(rc < 0) {
  42.         fprintf(stderr, "Couldn't write %s.\n", "image_generee.png");
  43.         return 1;
  44.         }
  45.     free_image(img);
  46.    
  47. }
  48.  
  49. void PD_function(struct hpgl_command *cmd, struct image *img, int *point_courant){
  50.     //1 determiner taille complete image
  51.     // SINON pour chaque commande , etudier les limites et reallouer
  52.     //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
  53.     int point_fin_trait[2];
  54.     for(int i=0;i<cmd->nparms;i+=2){
  55.        // récupération des positions du segment à tracer
  56.        //1 er extremite du segment
  57.        point_fin_trait[0]=cmd->parms[i];
  58.        point_fin_trait[1]=cmd->parms[i+1];
  59.        
  60.        //tracer la ligne = modifier le struct img, point courant = debut du segment
  61.        for(int ligne=point_courant[0];ligne<point_fin_trait[0];ligne++)     {
  62.         for(int colonne=point_courant[1];colonne<point_fin_trait[1];colonne++) {
  63.         //img->data[i][j]=;
  64.         }
  65.         }
  66.        //2 eme extremite du segment
  67.        point_courant[0]=point_fin_trait[0];
  68.        point_courant[1]=point_fin_trait[1];
  69.     }
  70.    
  71. }
  72.  
  73.  
  74. int
  75. main(int argc, char **argv) {
  76.     struct hpgl_file *hpf;
  77.     struct image *imgg;
  78.    
  79. /*
  80.     if(argc != 2) {
  81.         fprintf(stderr, "Syntax: %s filename\n", argv[0]);
  82.         exit(1);
  83.     }
  84. */
  85.  
  86.     hpf = hpgl_open("HPGL_Example.hpgl"); // modifié
  87.     if(hpf == null) {
  88.         perror("open");
  89.         exit(1);
  90.     }
  91.  
  92.     while(1) {
  93.         struct hpgl_command *cmd = hpgl_read(hpf);
  94.         if(cmd == null)
  95.             break;
  96.         printf("%c%c", cmd->command[0], cmd->command[1]);
  97.         for(int i = 0; i < cmd->nparms; i++) {
  98.             if(i > 0)
  99.                 printf(",");
  100.             printf("%d", cmd->parms[i]);
  101.         }
  102.        
  103.         printf(";");
  104.        
  105.         if(strcmp(cmd->command, "IN")==0){
  106.         imgg=IN_function(cmd);  
  107.         }else if(strcmp(cmd->command, "SP")==0){
  108.             SP_function(cmd);
  109.         }
  110.         else if(strcmp(cmd->command, "PU")==0){
  111.             PU_function(cmd, imgg);
  112.         }else if(strcmp(cmd->command, "PD"==0){
  113.             PD_function(cmd, imgg);
  114.         }
  115.        
  116.         hpgl_free_command(cmd);
  117.     }
  118.     printf("\n");
  119.     hpgl_close(hpf);
  120.  
  121.     return 0;
  122. }
  123.  
  124.  
  125. // FAIRE FONCTION IN : initialise l'état de la table traçante
  126.  
  127. //FAIRE FONCTION SP : SELECT PEN ou SET PEN choisit la plume numéro 1, normalement une plume noire
  128.  
  129. //FONCTION PU : PEN UP qui lève la plume
  130.  
  131. //FONCTION PU0, 0 qui lève la plume et se positionne aux coordonnées (0,0)
  132.  
  133. //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.017 seconds