Foros del Web » Programación para mayores de 30 ;) » C/C++ »

Mostrar imagen bmp con C

 Estas en el tema de Mostrar imagen bmp con C en el foro de C/C++ en Foros del Web. Buenas, estoy haciendo una aplicación que lee una imagen bmp, la guarda en un txt en binario y luego la vuelvo a leer para mostrarla ...
  #1 (permalink)  
Antiguo 19/07/2011, 14:50
 
Fecha de Ingreso: abril-2009
Mensajes: 63
Antigüedad: 15 años, 8 meses
Puntos: 0
Mostrar imagen bmp con C
Buenas, estoy haciendo una aplicación que lee una imagen bmp, la guarda en un txt en binario y luego la vuelvo a leer para mostrarla utilizando la libreria xlib pero estoy teniendo un problemilla para sacar la imagen, a ver si me podeis hechar un cable.

Este es el código que estoy utilizando.

Código C: 
Ver original
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdint.h>
  4. #include <stdlib.h>
  5. #include <X11/X.h>
  6. #include <X11/Xlib.h>
  7. #include <X11/Xutil.h>
  8.  
  9. FILE *fimg,*ftext;
  10.  
  11. void nombre_archivo(char texto[]);
  12. void leer_imagen();
  13. void abrir_imagen();
  14.  
  15. char nombre[20]="imagen.txt";
  16. char ruta[100]="/home/albert/Downloads/imagen.bmp";
  17.  
  18. typedef struct bmpFileHeader
  19. {
  20.   uint32_t magic;       /* 2 bytes de identificación */
  21.   uint32_t size;        /* Tamaño del archivo */
  22.   uint16_t resv1;       /* Reservado */
  23.   uint16_t resv2;       /* Reservado */
  24.   uint32_t offset;      /* Offset hasta hasta los datos de imagen */
  25. } bmpFileHeader;
  26.  
  27. typedef struct bmpInfoHeader
  28. {
  29.   uint32_t headersize;      /* Tamaño de la cabecera */
  30.   uint32_t width;           /* Ancho */
  31.   uint32_t height;          /* Alto */
  32.   uint16_t planes;          /* Planos de color (Siempre 1) */
  33.   uint16_t bpp;             /* bits por pixel */
  34.   uint32_t compress;        /* compresión */
  35.   uint32_t imgsize;         /* tamaño de los datos de imagen */
  36.   uint32_t bpmx;            /* Resolución X en bits por metro */
  37.   uint32_t bpmy;            /* Resolución Y en bits por metro */
  38.   uint32_t colors;          /* colors used en la paleta */
  39.   uint32_t imxtcolors;      /* Colores importantes. 0 si son todos */
  40. } bmpInfoHeader;
  41.  
  42. typedef struct {
  43.  
  44.     unsigned char r,g,b,junk;
  45.  
  46. } COLOURINDEX;
  47.  
  48. int main(){
  49.  
  50.     //nombre_archivo(ruta);
  51.     printf("%s\n",nombre);
  52.  
  53.     leer_imagen();
  54.     abrir_imagen();
  55.  
  56.     return 0;
  57. }
  58.  
  59. void leer_imagen(){
  60.  
  61.     bmpInfoHeader bInfoHeader;
  62.     bmpFileHeader header;
  63.  
  64.     fimg=fopen (ruta, "rb");
  65.     if (!fimg){
  66.         printf("no hay imagen");      /* Si no podemos leer, no hay imagen*/
  67.     }
  68.  
  69.     /* Leemos la cabecera de fichero completa */
  70.     fread(&header, sizeof(bmpFileHeader)-2, 1, fimg);
  71.     fread(&bInfoHeader, sizeof(bmpInfoHeader), 1, fimg);
  72.  
  73.     ftext=fopen(nombre,"wb");
  74.  
  75.     fwrite(&header,sizeof(bmpFileHeader)-2,1,ftext);
  76.     fwrite(&bInfoHeader,sizeof(bmpInfoHeader),1,ftext);
  77.  
  78.     fclose(fimg);
  79.     fclose(ftext);
  80.  
  81. }
  82.  
  83. void abrir_imagen(){
  84.  
  85.     ftext=fopen (nombre, "rb");
  86.  
  87.     bmpInfoHeader bInfoHeader;
  88.     bmpFileHeader header;
  89.  
  90.     fread(&header, sizeof(bmpFileHeader)-2, 1, ftext);
  91.     fread(&bInfoHeader, sizeof(bmpInfoHeader)-1, 1, ftext);
  92.  
  93.     int gotindex=1;
  94.     unsigned char junk,r,g,b;
  95.  
  96.     COLOURINDEX colourindex[256];
  97.  
  98.     int screen;
  99.     Display *display;
  100.     display = XOpenDisplay(NULL);
  101.     Window xwindow;
  102.  
  103.     screen = DefaultScreen(display);
  104.     xwindow = RootWindow(display,screen);
  105.  
  106.     int i,j;
  107.     long rgb;
  108.  
  109.     GC gr_context1=XCreateGC(display,xwindow,0,0);
  110.  
  111.        for (i=0;i<255;i++) {
  112.           colourindex[i].r = rand() % 256;
  113.           colourindex[i].g = rand() % 256;
  114.           colourindex[i].b = rand() % 256;
  115.           colourindex[i].junk = rand() % 256;
  116.        }
  117.        if (bInfoHeader.colors > 0) {
  118.           for (i=0;i<bInfoHeader.colors;i++) {
  119.              if (fread(&colourindex[i].b,sizeof(unsigned char),1,ftext) != 1) {
  120.                 fprintf(stderr,"Image read failed\n");
  121.                 exit(-1);
  122.              }
  123.              if (fread(&colourindex[i].g,sizeof(unsigned char),1,ftext) != 1) {
  124.                 fprintf(stderr,"Image read failed\n");
  125.                 exit(-1);
  126.              }
  127.              if (fread(&colourindex[i].r,sizeof(unsigned char),1,ftext) != 1) {
  128.                 fprintf(stderr,"Image read failed\n");
  129.                 exit(-1);
  130.              }
  131.              if (fread(&colourindex[i].junk,sizeof(unsigned char),1,ftext) != 1) {
  132.                 fprintf(stderr,"Image read failed\n");
  133.                 exit(-1);
  134.              }
  135.              fprintf(stderr,"%3d\t%3d\t%3d\t%3d\n",i,
  136.                 colourindex[i].r,colourindex[i].g,colourindex[i].b);
  137.           }
  138.           gotindex = 0;
  139.        }
  140.  
  141.     /* Nos desplazamos el valor de offset hasta llegar a la zona de los datos */
  142.     fseek(ftext, header.offset, SEEK_SET);
  143.  
  144.     /* Hay que invertir los indices porque la imagen se muestra al reves*/
  145.     for(j=(bInfoHeader.height) -1;j>=0;j--) {
  146.  
  147.         for(i=0;i<bInfoHeader.width;i++) {
  148.  
  149.             switch(bInfoHeader.bpp) {
  150.  
  151.             case 1:
  152.                 break;
  153.             case 4:
  154.                 break;
  155.             case 8:
  156.                 if(fread(&junk, sizeof(unsigned char), 1, ftext)!=1){
  157.  
  158.                     printf("error 1");
  159.                     exit(-1);
  160.  
  161.                 }
  162.                 if(gotindex){
  163.  
  164.                     putchar(colourindex[junk].r);
  165.                     putchar(colourindex[junk].g);
  166.                     putchar(colourindex[junk].b);
  167.  
  168.                 }
  169.                 else {
  170.  
  171.                     putchar(junk);
  172.  
  173.                 }
  174.  
  175.                 break;
  176.  
  177.             case 24:
  178.  
  179.                 if(fread(&b, sizeof(unsigned char), 1, ftext)!=1){
  180.  
  181.                     printf("error 2");
  182.                     exit(-1);
  183.  
  184.                 }
  185.                 if(fread(&g, sizeof(unsigned char),1, ftext)!=1){
  186.  
  187.                     printf("error 3");
  188.                     exit(-1);
  189.  
  190.                 }
  191.                 if(fread(&r, sizeof(unsigned char),1, ftext)!=1){
  192.  
  193.                     printf("error 4");
  194.                     exit(-1);
  195.  
  196.                 }
  197.                 /*Obtenemos el valor del color a partir del RGB*/
  198.                 rgb=65536 * r + 256 * g + b;
  199.                 /*Marcamos el color obtenido*/
  200.                 XSetForeground(display, gr_context1, rgb);
  201.                 /*Dibujamos el punto correspondiente*/
  202.                 XDrawPoint(display, xwindow, gr_context1, i, j);
  203.                 break;
  204.             }
  205.  
  206.         }//i
  207.         printf("\n");
  208.     }//j
  209.  
  210. }

Un saludo
  #2 (permalink)  
Antiguo 20/07/2011, 17:02
Avatar de Instru  
Fecha de Ingreso: noviembre-2002
Ubicación: Mexico
Mensajes: 2.751
Antigüedad: 22 años, 1 mes
Puntos: 52
Respuesta: Mostrar imagen bmp con C
Mmm. Tienes que ser mas especifico con el problema que tienes. Cual es el problema para empezar?

Saludos
  #3 (permalink)  
Antiguo 21/07/2011, 02:33
 
Fecha de Ingreso: abril-2009
Mensajes: 63
Antigüedad: 15 años, 8 meses
Puntos: 0
Respuesta: Mostrar imagen bmp con C
Siento no ser más explicito postee con prisas y bueno...

He solucionado el fallo anterior y el problema que tengo es que cuando llama a la función abrir_imagen no pinta los pixeles y da error.

Código C: 
Ver original
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdint.h>
  4. #include <stdlib.h>
  5. #include <X11/X.h>
  6. #include <X11/Xlib.h>
  7. #include <X11/Xutil.h>
  8.  
  9. void nombre_archivo(char texto[]);
  10. void abrir_imagen();
  11. void mostrar_imagen();
  12.  
  13. Display *display;
  14. Window win1;
  15. XSetWindowAttributes attributes;
  16. XFontStruct *fontinfo;
  17. GC gr_context1;
  18. XArc arcs[10];
  19. Pixmap pixmap;
  20. Visual *visual;
  21. int screen;
  22. int depth;
  23. int i;
  24. unsigned char grey,r,g,b;
  25.  
  26. FILE *fimg,*ftext;
  27.  
  28. char nombre[20]="imagen.txt";
  29. char ruta[100]="/home/albert/Downloads/imagen2.bmp";
  30.  
  31. typedef struct {
  32.  
  33.     unsigned char r,g,b,grey;
  34.  
  35. } COLOURINDEX;
  36.  
  37. typedef struct bmpFileHeader
  38. {
  39.     unsigned short int type;                 /* Magic identifier            */
  40.     unsigned int size;                       /* File size in bytes          */
  41.     unsigned short int reserved1, reserved2;
  42.     unsigned int offset;                     /* Offset to image data, bytes */
  43. } bmpFileHeader;
  44.  
  45. typedef struct bmpInfoHeader
  46. {
  47.     unsigned int size;               /* Header size in bytes      */
  48.     int width,height;                /* Width and height of image */
  49.     unsigned short int planes;       /* Number of colour planes   */
  50.     unsigned short int bpp;         /* Bits per pixel            */
  51.     unsigned int compression;        /* Compression type          */
  52.     unsigned int imagesize;          /* Image size in bytes       */
  53.     int xresolution,yresolution;     /* Pixels per meter          */
  54.     unsigned int colors;           /* Number of colours         */
  55.     unsigned int importantcolours;   /* Important colours         */
  56. } bmpInfoHeader;
  57.  
  58. bmpFileHeader header;
  59. bmpInfoHeader bInfoHeader;
  60.  
  61. int main(){
  62.  
  63.     fimg=fopen (ruta, "rb");
  64.     if (!fimg){
  65.         printf("no hay imagen");      /* Si no podemos leer, no hay imagen*/
  66.     }
  67.  
  68.     /* Leemos la cabecera de fichero completa */
  69.     fread(&header.type, sizeof(header.type), 1, fimg);
  70.     fread(&header.size, sizeof(header.size), 1, fimg);
  71.     fread(&header.reserved1, sizeof(header.reserved1), 1, fimg);
  72.     fread(&header.reserved2, sizeof(header.reserved2), 1, fimg);
  73.     fread(&header.offset, sizeof(header.offset), 1, fimg);
  74.  
  75.     fread(&bInfoHeader,sizeof(bmpFileHeader),1,fimg);
  76.  
  77.     ftext=fopen(nombre,"wb");
  78.  
  79.     fwrite(&header,sizeof(bmpFileHeader)-2,1,ftext);
  80.     fwrite(&bInfoHeader,sizeof(bmpInfoHeader),1,ftext);
  81.  
  82.     mostrar_imagen();
  83.  
  84.     return 0;
  85. }
  86.  
  87. void mostrar_imagen(){
  88.  
  89.     XGCValues gr_values;
  90.     XEvent event;
  91.  
  92.     setbuf(stdout, NULL);
  93.     setbuf(stderr, NULL);
  94.     display = XOpenDisplay(NULL);
  95.     screen = DefaultScreen(display);
  96.     visual = DefaultVisual(display,screen);
  97.     depth = DefaultDepth(display,screen);
  98.  
  99.     win1 = XCreateWindow(display, XRootWindow(display, screen), 200, 200,
  100.             bInfoHeader.width,bInfoHeader.height, 5, depth, InputOutput, visual,
  101.             CWBackPixel | CWBorderPixel | CWOverrideRedirect, &attributes);
  102.  
  103.     XSelectInput(display, win1, ExposureMask | ButtonPressMask | KeyPressMask);
  104.     pixmap = XCreatePixmap(display, win1, 200, 100, depth);
  105.     fontinfo = XLoadQueryFont(display, "6x10");
  106.     gr_values.font = fontinfo->fid;
  107.     gr_values.function = GXcopy;
  108.     gr_values.plane_mask = AllPlanes;
  109.     gr_values.foreground = BlackPixel(display,screen);
  110.     gr_values.background = WhitePixel(display,screen);
  111.     gr_context1 = XCreateGC(display, win1, GCFont | GCFunction | GCPlaneMask
  112.             | GCForeground | GCBackground, &gr_values);
  113.  
  114.  
  115.     XMapWindow(display, win1);
  116.  
  117.     abrir_imagen();
  118.  
  119.     XDrawString(display, win1, gr_context1, 10, 32, "Now press a key to exit",23);
  120.     XFlush(display);
  121.  
  122.     do {
  123.         XNextEvent(display, &event);
  124.     } while (event.type != KeyPress);
  125.  
  126.     printf("closing display\n");
  127.     XCloseDisplay(display);
  128.  
  129. }
  130.  
  131. void abrir_imagen(){
  132.  
  133.     int gotindex=1;
  134.  
  135.     COLOURINDEX colourindex[256];
  136.  
  137.     unsigned char r,g,b,grey;
  138.  
  139.     int i,j;
  140.     long rgb;
  141.  
  142.     /* Nos desplazamos el valor de offset hasta llegar a la zona de los datos */
  143.     fseek(fimg, header.offset, SEEK_SET);
  144.  
  145.     /* Hay que invertir los indices porque la imagen se muestra al reves*/
  146.     for(j=(bInfoHeader.height) -1;j>=0;j--) {
  147.  
  148.         for(i=(bInfoHeader.width) -1;j>=0;i--) {
  149.  
  150.             switch(bInfoHeader.bpp) {
  151.  
  152.             case 1:
  153.                 break;
  154.             case 4:
  155.                 break;
  156.             case 8:
  157.                 if (fread(&grey, sizeof(unsigned char), 1, fimg) != 1) {
  158.                     fprintf(stderr, "Image read failed\n");
  159.                     exit(-1);
  160.                 }
  161.                 if (gotindex) {
  162.                     putchar(r);
  163.                     putchar(g);
  164.                     putchar(b);
  165.                 } else {
  166.                     putchar(grey);
  167.                 }
  168.                 break;
  169.  
  170.             case 24:
  171.  
  172.                 if (fread(&b, sizeof(unsigned char), 1, fimg) != 1) {
  173.                     fprintf(stderr, "Image read failed 1\n");
  174.                     exit(-1);
  175.                 }
  176.                 if (fread(&g, sizeof(unsigned char), 1, fimg) != 1) {
  177.                     fprintf(stderr, "Image read failed 2\n");
  178.                     exit(-1);
  179.                 }
  180.                 if (fread(&r, sizeof(unsigned char), 1, fimg) != 1) {
  181.                     fprintf(stderr, "Image read failed 3\n");
  182.                     exit(-1);
  183.                 }
  184.  
  185.                 /*Obtenemos el valor del color a partir del RGB*/
  186.                 rgb=65536 * r + 256 * g + b;
  187.                 /*Marcamos el color obtenido*/
  188.                 XSetForeground(display, gr_context1, rgb);
  189.                 /*Dibujamos el punto correspondiente*/
  190.                 XDrawPoint(display, pixmap, gr_context1, i, j);
  191.                 break;
  192.             }
  193.  
  194.         }//i
  195.         printf("\n");
  196.     }//j
  197.     fclose(fimg);
  198.     fclose(ftext);
  199. }
Última edición por KatonSP; 21/07/2011 a las 04:41 Razón: corregir
  #4 (permalink)  
Antiguo 21/07/2011, 08:42
 
Fecha de Ingreso: junio-2008
Ubicación: Seattle, USA
Mensajes: 733
Antigüedad: 16 años, 6 meses
Puntos: 61
Respuesta: Mostrar imagen bmp con C
Indica cual es el error, o como te das cuenta del mismo. Realmente quieres ayuda?
  #5 (permalink)  
Antiguo 21/07/2011, 11:03
 
Fecha de Ingreso: abril-2009
Mensajes: 63
Antigüedad: 15 años, 8 meses
Puntos: 0
Respuesta: Mostrar imagen bmp con C
El error está en que la parte que pongo ahora debería pintar los píxeles en la ventana pero no lo hace, está en el método abrir_imagen() que es llamado desde mostrar_imagen().

Código C: 
Ver original
  1. rgb=65536 * r + 256 * g + b;
  2.                 /*Marcamos el color obtenido*/
  3.                 XSetForeground(display, gr_context1, rgb);
  4.                 /*Dibujamos el punto correspondiente*/
  5.                 XDrawPoint(display, pixmap, gr_context1, i, j);
  #6 (permalink)  
Antiguo 21/07/2011, 20:13
Avatar de Instru  
Fecha de Ingreso: noviembre-2002
Ubicación: Mexico
Mensajes: 2.751
Antigüedad: 22 años, 1 mes
Puntos: 52
Respuesta: Mostrar imagen bmp con C
Ok. Bueno. Mira, por lo general en la mayoria de las APIs, el dibujado de una "ventana" es un ciclo, ya que le ventana debe estar siendo dibujada constantemente. Para esto, es comun ver funciones o metodos para mmmm "actualizar" o "repintar" la pantalla.

Yo veo que solo pones pixeles en un buffer. Pero no creo que eso sea suficiente para mostrarlo en la pantalla.

Tambien veo que en mostrar_imagen, tienes un pequeño ciclo para procesar lo mensajes.

Pero en ningun lado le estas diciendo como pintar la pantalla. No se si me explico.
Posiblemente uno de los mensajes sea precisamente eso, la necesidad de pintar algo.

No conozco mucho las Xlibs, pero finalmente tambien es una API para manejar ventanas(entre otras cosas).

Saludos
  #7 (permalink)  
Antiguo 26/07/2011, 10:36
 
Fecha de Ingreso: abril-2009
Mensajes: 63
Antigüedad: 15 años, 8 meses
Puntos: 0
Respuesta: Mostrar imagen bmp con C
Ya he conseguido, gracias por echarme una mano Instru, el problema que tenía era que después de pintar la imagen volvia a pintar toda la pantalla de negro.

Dejo el código que ya funciona.

Código C: 
Ver original
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdint.h>
  4. #include <stdlib.h>
  5. #include <X11/X.h>
  6. #include <X11/Xlib.h>
  7. #include <X11/Xutil.h>
  8.  
  9. void nombre_archivo(char texto[]);
  10. void abrir_imagen();
  11. void mostrar_imagen();
  12.  
  13. Display *display;
  14. Window win1;
  15. XSetWindowAttributes attributes;
  16. XFontStruct *fontinfo;
  17. GC gr_context1;
  18. XArc arcs[10];
  19. Pixmap pixmap;
  20. Visual *visual;
  21. int screen;
  22. int depth;
  23. int i;
  24. unsigned char grey,r,g,b;
  25.  
  26. FILE *fimg,*ftext;
  27.  
  28. char nombre[20]="imagen.txt";
  29. char ruta[100]="/home/albert/Downloads/imagen2.bmp";
  30.  
  31. typedef struct {
  32.  
  33.     unsigned char r,g,b,grey;
  34.  
  35. } COLOURINDEX;
  36.  
  37. typedef struct bmpFileHeader
  38. {
  39.     unsigned short int type;                 /* Magic identifier            */
  40.     unsigned int size;                       /* File size in bytes          */
  41.     unsigned short int reserved1, reserved2;
  42.     unsigned int offset;                     /* Offset to image data, bytes */
  43. } bmpFileHeader;
  44.  
  45. typedef struct bmpInfoHeader
  46. {
  47.     unsigned int size;               /* Header size in bytes      */
  48.     int width,height;                /* Width and height of image */
  49.     unsigned short int planes;       /* Number of colour planes   */
  50.     unsigned short int bpp;         /* Bits per pixel            */
  51.     unsigned int compression;        /* Compression type          */
  52.     unsigned int imagesize;          /* Image size in bytes       */
  53.     int xresolution,yresolution;     /* Pixels per meter          */
  54.     unsigned int colors;           /* Number of colours         */
  55.     unsigned int importantcolours;   /* Important colours         */
  56. } bmpInfoHeader;
  57.  
  58. bmpFileHeader header;
  59. bmpInfoHeader bInfoHeader;
  60.  
  61. int main(){
  62.  
  63.     fimg=fopen (ruta, "rb");
  64.     if (!fimg){
  65.         printf("no hay imagen");      /* Si no podemos leer, no hay imagen*/
  66.     }
  67.  
  68.     /* Leemos la cabecera de fichero completa */
  69.     fread(&header.type, sizeof(header.type), 1, fimg);
  70.     fread(&header.size, sizeof(header.size), 1, fimg);
  71.     fread(&header.reserved1, sizeof(header.reserved1), 1, fimg);
  72.     fread(&header.reserved2, sizeof(header.reserved2), 1, fimg);
  73.     fread(&header.offset, sizeof(header.offset), 1, fimg);
  74.  
  75.     fread(&bInfoHeader,sizeof(bmpFileHeader),1,fimg);
  76.  
  77.     ftext=fopen(nombre,"wb");
  78.  
  79.     fwrite(&header,sizeof(bmpFileHeader)-2,1,ftext);
  80.     fwrite(&bInfoHeader,sizeof(bmpInfoHeader),1,ftext);
  81.  
  82.     mostrar_imagen();
  83.  
  84.     fclose(fimg);
  85.     fclose(ftext);
  86.  
  87.     return 0;
  88. }
  89.  
  90. void mostrar_imagen(){
  91.  
  92.     //XGCValues gr_values;
  93.     XEvent event;
  94.  
  95.     setbuf(stdout, NULL);
  96.     setbuf(stderr, NULL);
  97.     display = XOpenDisplay(NULL);
  98.     screen = DefaultScreen(display);
  99.     visual = DefaultVisual(display,screen);
  100.     depth = DefaultDepth(display,screen);
  101.     //attributes.background_pixel = XWhitePixel(display, screen);
  102.     //attributes.border_pixel = XBlackPixel(display, screen);
  103.     attributes.override_redirect = 0;
  104.  
  105.     win1 = XCreateWindow(display, XRootWindow(display, screen), 200, 200, bInfoHeader.width,
  106.             bInfoHeader.height, 5, depth, InputOutput, visual, CWBackPixel | CWBorderPixel
  107.                     | CWOverrideRedirect, &attributes);
  108.  
  109.     XSelectInput(display, win1, ExposureMask | ButtonPressMask | KeyPressMask);
  110.     pixmap = XCreatePixmap(display, win1, bInfoHeader.width, bInfoHeader.height, depth);
  111.     /*fontinfo = XLoadQueryFont(display, "6x10");
  112.     gr_values.font = fontinfo->fid;
  113.     gr_values.function = GXcopy;
  114.     gr_values.plane_mask = AllPlanes;
  115.     gr_values.foreground = BlackPixel(display,screen);
  116.     gr_values.background = WhitePixel(display,screen);*/
  117.     gr_context1 = XCreateGC(display, win1, 0, 0);
  118.  
  119.     //XDefineCursor(display, win1, XCreateFontCursor(display, XC_heart));
  120.     XMapWindow(display, win1);
  121.  
  122.     /*do {
  123.         XNextEvent(display, &event);
  124.         if (event.type == Expose) {
  125.  
  126.             //XCopyArea(display, win1, pixmap, gr_context1, 50, 25, bInfoHeader.width, bInfoHeader.height, 0,
  127.                     0);
  128.             XSetFunction(display, gr_context1, GXinvert);
  129.             XDrawImageString(display, pixmap, gr_context1, 80, 45, "pixmap", 6);
  130.             XDrawImageString(display, pixmap, gr_context1, 90, 60, "copy", 4);
  131.             XSetFunction(display, gr_context1, GXcopy);
  132.             XSetForeground(display, gr_context1, 505);/
  133.  
  134.         }
  135.     } while (event.type != KeyPress);*/
  136.  
  137.     XCopyArea(display, pixmap, win1, gr_context1, 0, 0, bInfoHeader.width, bInfoHeader.height, 0, 0);
  138.     abrir_imagen();
  139.     //XDrawString(display, win1, gr_context1, 10, 32, "Now press a key to exit",23);
  140.  
  141.     XFlush(display);
  142.  
  143.     do {
  144.         XNextEvent(display, &event);
  145.     } while (event.type != KeyPress);
  146.  
  147.     printf("closing display\n");
  148.     XCloseDisplay(display);
  149.  
  150. }
  151.  
  152. void abrir_imagen(){
  153.  
  154.     int gotindex=1;
  155.  
  156.     unsigned char r,g,b,grey;
  157.  
  158.     int i,j;
  159.     long rgb;
  160.  
  161.     /* Nos desplazamos el valor de offset hasta llegar a la zona de los datos */
  162.     fseek(fimg, header.offset, SEEK_SET);
  163.  
  164.     /* Hay que invertir los indices porque la imagen se muestra al reves*/
  165.     for(j=bInfoHeader.height-1;j>=0;j--) {
  166.  
  167.         for(i=bInfoHeader.width-1;i>=0;i--) {
  168.  
  169.             switch(bInfoHeader.bpp) {
  170.  
  171.             case 1:
  172.                 break;
  173.             case 4:
  174.                 break;
  175.             case 8:
  176.                 if (fread(&grey, sizeof(unsigned char), 1, fimg) != 1) {
  177.                     fprintf(stderr, "Image read failed\n");
  178.                     exit(-1);
  179.                 }
  180.                 if (gotindex) {
  181.                     putchar(r);
  182.                     putchar(g);
  183.                     putchar(b);
  184.                 } else {
  185.                     putchar(grey);
  186.                 }
  187.                 break;
  188.  
  189.             case 24:
  190.                 if (fread(&b, sizeof(unsigned char), 1, fimg) != 1) {
  191.                     fprintf(stderr, "Image read failed 1\n");
  192.  
  193.                     exit(-1);
  194.                 }
  195.                 if (fread(&g, sizeof(unsigned char), 1, fimg) != 1) {
  196.                     fprintf(stderr, "Image read failed 2\n");
  197.                     exit(-1);
  198.                 }
  199.                 if (fread(&r, sizeof(unsigned char), 1, fimg) != 1) {
  200.                     fprintf(stderr, "Image read failed 3\n");
  201.                     exit(-1);
  202.                 }
  203.  
  204.                 /*Obtenemos el valor del color a partir del RGB*/
  205.                 rgb=65536 * r + 256 * g + b;
  206.                 /*Marcamos el color obtenido*/
  207.                 XSetForeground(display, gr_context1, rgb);
  208.                 /*Dibujamos el punto correspondiente*/
  209.                 XDrawPoint(display, win1, gr_context1, i, j);
  210.                 break;
  211.             }
  212.  
  213.         }//i
  214.         printf("\n");
  215.     }//j
  216.  
  217. }

Etiquetas: Ninguno
Atención: Estás leyendo un tema que no tiene actividad desde hace más de 6 MESES, te recomendamos abrir un Nuevo tema en lugar de responder al actual.
Respuesta


« Tema Anterior | Próximo Tema »


La zona horaria es GMT -6. Ahora son las 18:28.