guardar una imagen bmp

[m@o_614]

Saludos

Tengo el siguiente código en C++ que tiene una función llamada Bresenham(), que nos va a dibujar una(s) linea(s) simple en la ventana. Una vez que se dibujó la línea, el usuario debe de dar clic derecho en la ventana para que las líneas se guarden como una imagen bmp. Para esto tengo que crear dos estructuras: bmpInfoHeader y bmpFileHeader. El problema que tengo es que en la estructura de bmpFileHeader no se cómo calcular los campos de altura y anchura, y al momento de abrir la imagen no me aparece nada

Código (cpp) [Seleccionar] Expandir

#include<windows.h>
#include<stdio.h>
#include<stdlib.h>
#include<stdint.h>
#include<gl/glut.h>

typedef struct
{
   uint32_t tamanio;
   uint16_t campoReservado;
   uint32_t offset;
}bmpFileHeader;

typedef struct
{
   uint32_t tamanioEncabezado;
   uint32_t anchura;
   uint32_t altura;
   uint16_t planos;
   uint16_t profundidadModeloColor;
   uint32_t compresion;
   uint32_t tamanioImagen;
   uint32_t bmpx;
   uint32_t bmpy;
   uint32_t colores;
   uint32_t impColores;
}bmpInfoHeader;

float a[90000];
int x0=0,y0=0,xf=0,yf=0;
int puedeImprimir=0;
FILE *bmp = NULL;
unsigned char *imagen;
bmpInfoHeader infoEncabezado;
bmpFileHeader encabezadoArchivo;

void init(void);
void putpixel(int x,int y);
void Bresenham(int x0,int y0,int x1,int y1);
void display(void);
void onMotion(int x,int y);
void onMouse(int button, int e, int x, int y);
void onPassive(int x,int y);
void crearEncabezadoInformacion(bmpInfoHeader *infoEncabezado);
void crearEncabezadoArchivo(bmpFileHeader *encabezadoArchivo);
void Guardar(bmpFileHeader *encabezadoArchivo,bmpInfoHeader *infoEncabezado);

int main()
{
   glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB|GLUT_DEPTH);
   glutInitWindowSize(300, 300);
   glutInitWindowPosition(100, 100);
   glutCreateWindow("Practica 2. Trazo de lineas con mouse");
   init();
   glutDisplayFunc(display);
   glutMotionFunc(onMotion);
   glutMouseFunc(onMouse);
   glutPassiveMotionFunc(onPassive);
   glutMainLoop();
}

void init(void)
{
  glClearColor(1.0, 1.0, 1.0, 0.0);
  glMatrixMode(GL_PROJECTION);
  gluOrtho2D(0.0, 300.0, 0.0,300.0);
}

void putpixel(int x,int y)
{
   glColor3f(0.0, 0.0,0.0);
   glBegin(GL_POINTS);
   glVertex2i(x,y);
   glEnd();
}

void Bresenham(int x0,int y0,int x1,int y1)
{
   int dx,dy,p,x,y,pasox = 1,pasoy = 1,dosDymenosDx,dosDy,i;
   glColor3f(0.0,0.0,1.0);
   dx = x1-x0;
dy = y1-y0;

   if(dx < 0)
      dx = dx*-1;
   if(dy < 0)
      dy = dy*-1;
   if(x1 < x0)
      pasox = -1;
   if(y1 < y0)
      pasoy = -1;

   x = x0;
   y = y0;
if( dx > dy )
   {
       putpixel(x,y);
       p = 2 * dy - dx;
       dosDymenosDx = 2 * ( dy - dx );
       dosDy = 2 * dy;
       for( i = 0; i < dx; i++ )
       {
            if( p >= 0 )
            {
                y += pasoy;
                p += dosDymenosDx;
            }
            else
               p += dosDy;
            x += pasox;
            putpixel(x,y);
       }
  }
  else
  {
      putpixel(x,y);
      p = 2*dx - dy;
      dosDymenosDx = 2 * ( dx - dy );
      dosDy = 2*dx;
      for( i = 0; i < dy; i++ )
      {
          if( p >= 0 )
          {
              x += pasox;
              p += dosDymenosDx;
          }
          else
             p += dosDy;
          y += pasoy;
          putpixel(x,y);
      }
  }
  glFlush();
}

void display(void)
{
   glClear(GL_COLOR_BUFFER_BIT);
   if(puedeImprimir==1)
      glDrawPixels(300,300,GL_RGB,GL_UNSIGNED_BYTE,a);
   Bresenham(x0,y0,xf,yf);
   glFlush();
}

void onMotion(int x,int y)
{
   xf = x;
   yf = 300-y;
   glutPostRedisplay();
}

void onMouse(int button, int e, int x, int y)
{
   unsigned char media;
   if((button == GLUT_LEFT_BUTTON) && (e == GLUT_DOWN))
   {
       puedeImprimir = 1;
       x0 = xf = x;
       y0 = yf = abs(300-y);
   }
   else if((button == GLUT_LEFT_BUTTON) && (e == GLUT_UP))
      puedeImprimir = 0;
   else if((button == GLUT_RIGHT_BUTTON) && (e == GLUT_UP))
   {
       //Abrir();
       crearEncabezadoInformacion(&infoEncabezado);
       Guardar(&encabezadoArchivo,&infoEncabezado);
   }
}

void crearEncabezadoInformacion(bmpInfoHeader *infoEncabezado)
{
   infoEncabezado = (bmpInfoHeader*)malloc(sizeof(bmpInfoHeader));

   infoEncabezado->tamanioEncabezado = sizeof(bmpInfoHeader);
   infoEncabezado->anchura = ????;
   infoEncabezado->altura = ????;
   infoEncabezado->planos = 1;
   infoEncabezado->profundidadModeloColor = 24;
   infoEncabezado->compresion = BI_RGB;
   infoEncabezado->tamanioImagen = ?????;
   infoEncabezado->bmpx = 0;
   infoEncabezado->bmpy = 0;
   infoEncabezado->colores = 0;
   infoEncabezado->impColores = 0;
}

void Guardar(bmpFileHeader *encabezadoArchivo,unsigned char *imagen,bmpInfoHeader *info)
{
   uint16_t firma;
   if((bmp = fopen("practica no. 7.bmp","wt"))!= NULL)
   {
       firma = 0x4D42;
       encabezadoArchivo->campoReservado = 0;
       encabezadoArchivo->offset = sizeof(bmpFileHeader)+sizeof(bmpInfoHeader)+2;
       encabezadoArchivo->tamanio = info->tamanioImagen+sizeof(bmpFileHeader)+sizeof(bmpInfoHeader);
       fwrite(&firma,sizeof(firma),1,bmp);
       fwrite(encabezadoArchivo,sizeof(bmpFileHeader),1,bmp);
       fwrite(info,sizeof(bmpInfoHeader),1,bmp);
   }
   else
      printf("No se pudo crear fichero");
}

void onPassive(int x,int y)
{
   glReadPixels(0.0,0.0,300.0,300.0,GL_RGB,GL_UNSIGNED_BYTE,a);
   Bresenham(x0,y0,xf,yf);
}



alguna idea de cómo arreglarlo?