bmp.c

图像置乱代码

#include "bmp.h"

#include <stdio.h>
#include <fcntl.h>
#include <string.h>
#include <math.h>
#include <malloc.h>
#include <sys/file.h>
/*------xiong------*/
Imrect *BmpToImrect(char *fileName)
{
  Imrect *tempImrect=NULL;
  int m_width,m_height;
  unsigned char *m_pData=NULL;
  unsigned char *m_pPalette=NULL;
  int i,j;
  int in_fd,n_chars;
  unsigned char **m_pMatrix=NULL;
   BITMAPFILEHEADER m_bmfh;
   BITMAPINFOHEADER m_bmih;
   in_fd=open(fileName, O_RDONLY);
   n_chars=read(in_fd, (char *)&(m_bmfh.bfType), 2);
   n_chars=read(in_fd, (char *)&(m_bmfh.bfSize), 4);
   n_chars=read(in_fd, (char *)&(m_bmfh.bfReserved1), 2);
   n_chars=read(in_fd, (char *)&(m_bmfh.bfReserved2), 2);
   n_chars=read(in_fd, (char *)&(m_bmfh.bfOffBits), 4);
   n_chars=read(in_fd, (char *)&m_bmih.biSize, 4);
   n_chars=read(in_fd, (char *)&m_bmih.biWidth, 4);
   n_chars=read(in_fd, (char *)&m_bmih.biHeight, 4);
   n_chars=read(in_fd, (char *)&m_bmih.biPlanes, 2);
   n_chars=read(in_fd, (char *)&m_bmih.biBitCount, 2);
   n_chars=read(in_fd, (char *)&m_bmih.biCompression, 4);
   n_chars=read(in_fd, (char *)&m_bmih.biSizeImage, 4);
   n_chars=read(in_fd, (char *)&m_bmih.biXPelsPerMeter, 4);
   n_chars=read(in_fd, (char *)&m_bmih.biYPelsPerMeter, 4);
   n_chars=read(in_fd, (char *)&m_bmih.biClrUsed, 4);
   n_chars=read(in_fd, (char *)&m_bmih.biClrImportant, 4);


  

   m_width=m_bmih.biWidth;
   m_height=m_bmih.biHeight;

   n_chars=m_bmfh.bfOffBits-54;
   m_pPalette=(unsigned char*)malloc(n_chars*sizeof(unsigned char));
   n_chars=read(in_fd, m_pPalette, n_chars);
  
  
   m_pData=(unsigned char*)malloc(m_width*m_height*sizeof(unsigned char));
 
   lseek(in_fd, 0, SEEK_SET);
   lseek(in_fd, m_bmfh.bfOffBits, SEEK_CUR);
  
   n_chars=read(in_fd, m_pData, m_width*m_height);
   
   m_pMatrix=(unsigned char**)malloc(m_height*sizeof(unsigned char*));
  
   for(i=0; i<m_height; i++) 
         { 
                   m_pMatrix[i]=(unsigned char*)malloc(m_width*sizeof(unsigned char)); 
                  
         }
 
   for(i=0; i<m_height; i++)
   {
       for(j=0; j<m_width; j++)
       {
          m_pMatrix[i][j]= *(m_pData+m_width*(m_height-1-i)+j);
         
       }
   }
   
   tempImrect= im_alloc(m_height, m_width,NULL,float_v);
   for(i=0;i<m_height;i++)
     for(j=0;j<m_width;j++)
         im_put_pixf(255.0, tempImrect, i, j);
   for(i=0; i<m_height; i++)
   {
       for(j=0; j<m_width; j++)
       {
            im_put_pixf((float)m_pMatrix[i][j], tempImrect, i, j);
       }
   }

   free(m_pPalette);
   free(m_pData);
   for(i=0; i<m_height; i++) 
        free(m_pMatrix[i]);
   free(m_pMatrix);
   return tempImrect;
}
/*----------lxh-------------*/
void readBMP(const char *fileName)
{
	BMPHEADER * bh;
	DATA_MATRIX * mat;
	bh = (BMPHEADER *)getBmpHeader(fileName);
	mat = (DATA_MATRIX *)dataview_bmp8(fileName, bh);
}


int fputWord(FILE *fp,int n)
{
	fputc(n,fp);
	fputc((n>>8),fp);
	return 0;
}

int fputLong(FILE *fp,long n)
{	
	fputc((int)(n&0xff),fp);
	fputc((int)((n>>8)&0xff),fp);
	fputc((int)((n>>16)&0xff),fp);
	fputc((int)((n>>24)&0xff),fp);
	return 0;
}

void printRGBQUAD(RGBQUAD * x)
{
	printf("R(%d);G(%d);B(%d)\n", 
		x->rgbRed, x->rgbGreen, x->rgbBlue);
}

BMPHEADER * getBmpHeader(const char * BmpFileName)
{
	FILE * fp;
	BMPHEADER * head;

	BITMAPFILEHEADER * bf;
	BITMAPINFOHEADER * bi;

 	head = (BMPHEADER *)malloc(sizeof(BMPHEADER));
	bf = &head->BFH;
	bi = &head->BIH;

    if(BmpFileName == NULL || (fp = fopen(BmpFileName, "r")) == NULL)
	{
		printf("File %s not found!\n", BmpFileName);
		return NULL;
	}
	fread((void *)&bf->bfType, sizeof(WORD), 1, fp);
	fread((void *)&bf->bfSize, sizeof(DWORD), 1, fp);
	fread((void *)&bf->bfReserved1, sizeof(WORD), 1, fp);
	fread((void *)&bf->bfReserved2, sizeof(WORD), 1, fp);
	fread((void *)&bf->bfOffBits, sizeof(DWORD), 1, fp);

	fread((void *)&bi->biSize, sizeof(DWORD), 1, fp);
	fread((void *)&bi->biWidth, sizeof(LONG), 1, fp);
	fread((void *)&bi->biHeight, sizeof(LONG), 1, fp);
	fread((void *)&bi->biPlanes, sizeof(WORD), 1, fp);
	fread((void *)&bi->biBitCount, sizeof(WORD), 1, fp);
	fread((void *)&bi->biCompression, sizeof(DWORD), 1, fp);
	fread((void *)&bi->biSizeImage, sizeof(DWORD), 1, fp);
	fread((void *)&bi->biXPelsPerMeter, sizeof(LONG), 1, fp);
	fread((void *)&bi->biYPelsPerMeter, sizeof(LONG), 1, fp);
	fread((void *)&bi->biClrUsed, sizeof(DWORD), 1, fp);
	fread((void *)&bi->biClrImportant, sizeof(DWORD), 1, fp);


	printf("\n====================File Header===================\n");
	printf("bfType = %x   \n", bf->bfType);
	printf("bfOffBits = %d\n", bf->bfOffBits );
	printf("bfSize = %d   \n", bf->bfSize );

	printf("\n====================Info Header===================\n");
	printf("biSize = %d			\n", bi->biSize);
	printf("biWidth = %d		\n", bi->biWidth );
	printf("biHeight = %d		\n", bi->biHeight);
	printf("biPlanes = %d		\n", bi->biPlanes);
	printf("biBitCount = %d		\n", bi->biBitCount  );
	printf("biClrUsed = %d		\n", bi->biClrUsed );
	printf("biCompression = %d	\n", bi->biCompression);
	printf("biSizeImage = %d	\n", bi->biSizeImage);
	printf("biXPelsPerMeter = %d\n", bi->biXPelsPerMeter);
	printf("biYPelsPerMeter = %d\n", bi->biYPelsPerMeter);
	printf("biClrImportant = %d	\n", bi->biClrImportant );

	printf("\n===================   END   ====================\n");

	fclose(fp);
	
	return head;
}

RGBQUAD* getBmpPalette(const char * BmpFileName, BMPHEADER * header)
{
	BITMAPFILEHEADER * bf = &header->BFH;
	BITMAPINFOHEADER * bi = &header->BIH;
	FILE * fp;
	RGBQUAD *palette;
	int i;
	WORD NumColors;

        if(BmpFileName == NULL || (fp = fopen(BmpFileName, "r")) == NULL)
	{
		printf("File %s not found!\n", BmpFileName);
		return NULL;
	}
    
	if(bi->biClrUsed != 0)
		NumColors = (WORD)bi->biClrUsed;
	else
        switch (bi->biBitCount)
    	{
		case 1:
			NumColors = 2;
			break;
        	case 4:
      		    NumColors = 16;
        	    break;
        	case 8:
        	    NumColors = 256;
        	    break;
        	case 24:
			fclose(fp);
			return NULL;
            default:
			printf("Can't handle this biBitCount: %d!\n", bi->biBitCount);
			fclose(fp);
			return NULL;
        }
	palette = (RGBQUAD *)malloc(sizeof(RGBQUAD)*NumColors);
	printf("\nNumColors = %d\n",NumColors);
	fseek(fp, HEADEROFFSET, SEEK_SET);
	for (i = 0; i < NumColors; i++)
		fread((void *)&palette[i], sizeof(RGBQUAD), 1, fp);
	
	for (i = 0; i < NumColors; i++)
		printf("%d\t%d\t%d\n", 
			palette[i].rgbBlue, palette[i].rgbGreen, palette[i].rgbRed);
    
	fclose(fp);
	return palette;
}

int BmpHeaderView(BMPHEADER * header)
{
	BMPHEADER * head = (BMPHEADER *)header;
	BITMAPFILEHEADER * bf = &head->BFH;
	BITMAPINFOHEADER * bi = &head->BIH;

	if(head == NULL)
	{
		printf("No File header info !\n");
		return -1;
	}

	printf("\n====================File Header===================\n");
	printf("bfType = %x   \n", bf->bfType);
	printf("bfOffBits = %d\n", bf->bfOffBits );
	printf("bfSize = %d   \n", bf->bfSize );

	printf("\n====================Info Header===================\n");
	printf("biSize = %d			\n", bi->biSize);
	printf("biWidth = %d		\n", bi->biWidth );
	printf("biHeight = %d		\n", bi->biHeight);
	printf("biPlanes = %d		\n", bi->biPlanes);
	printf("biBitCount = %d		\n", bi->biBitCount  );
	printf("biClrUsed = %d		\n", bi->biClrUsed );
	printf("biCompression = %d	\n", bi->biCompression);
	printf("biSizeImage = %d	\n", bi->biSizeImage);
	printf("biXPelsPerMeter = %d\n", bi->biXPelsPerMeter);
	printf("biYPelsPerMeter = %d\n", bi->biYPelsPerMeter);
	printf("biClrImportant = %d	\n", bi->biClrImportant );

	printf("\n===================   END   ====================\n");

	return 0;
}

DATA_MATRIX * dataview_bmp8(const char * filename, BMPHEADER * header)
{
	BITMAPFILEHEADER * bf = &header->BFH;
	BITMAPINFOHEADER * bi = &header->BIH;
	FILE*	fp;
	BYTE	buf;
	int	i, j, k;
	int	cnt = 0;
	LONG	real_width;
	int	rows, cols;
	DATA_MATRIX * data_tmp;

	if(filename == NULL || (fp = fopen(filename, "r")) == NULL)
	{
		printf("File %s not found!\n", filename);
		return NULL;
	}
	if(bi->biBitCount != 8)
	{
		printf("File %s is not an image of 8 bits!\n", filename);
		return NULL;
	}

	/* Preparing */

	rows = bi->biHeight;
	cols = bi->biWidth;
	data_tmp = (DATA_MATRIX *)DATA_MATRIX_new(rows, cols);

	real_width = WIDTHBYTES(bi->biWidth * bi->biBitCount);
	printf("\nThe Image real width =%ld \n",real_width);

	fseek(fp, bf->bfOffBits, SEEK_SET);
	for (i = 0; i < rows; i++)
	{
		for (j = 0; j < real_width; j++)
		{
			memset((void *)&buf, 0, sizeof(BYTE));
			fread((void *)&buf,sizeof(BYTE),1,  fp);
			printf("%4d", buf);
			cnt++;
			data_tmp->data[rows-i-1][j] = buf;

		}
		printf("\n");
	}

	printf("\n\n The image color num cnt = %d\n", cnt);
	fclose(fp);
	return data_tmp;
}


/************************** added on 2004-11-23 ************************/
int writeBMP8(const  BMPHEADER * header, const DATA_MATRIX * Data,const char * filename)
{
        BMPHEADER * head = (BMPHEADER *)header;

        BITMAPFILEHEADER * bf = &head->BFH;
        BITMAPINFOHEADER * bi = &head->BIH;

        FILE * fp;

        BYTE buf;
        int i, j, k;
        int cnt = 0;
        long image_byte_width;
        long real_width;
        
        if((head == NULL)||(Data == NULL))
        {
                printf("Data error!\n");
                return -1;
        }
        if(filename == NULL || (fp = fopen(filename, "w")) == NULL)
        {
                printf("File %s not found!\n", filename);
                return -1;
        }
                
        image_byte_width = bi->biWidth * 3;
        real_width = WIDTHBYTES(bi->biWidth * bi->biBitCount);