cdib.cpp

数字图像处理的程序

//--------------------------------------------------------------------------
//	cdib.cpp
//                             
//            All copyrights reserved by ECNU
//--------------------------------------------------------------------------
//	Abstract:
//		图像类CDIB的实装
//--------------------------------------------------------------------------
//	Hostory:
//		ver.1.0.0
//--------------------------------------------------------------------------
//	Contents:
//		int CDIB::freeMember(void)
//		CDIB::CDIB()
//		CDIB::~CDIB()
//		int CDIB::create(int w, int h, int nbit)
//		BOOL CDIB::isGray()
//--------------------------------------------------------------------------
#include "stdafx.h"
#include "cdib.h"

#include <iostream>
#include <iomanip>
#include <malloc.h>
#include <memory.h>
/*--------------------------------------------------------------------------
函数名	CDIB::freeMember

形式	int CDIB::freeMember(void)

---------------------------------------------------------------------------*/
int CDIB::freeMember(void)
{
	if (m_dc!=NULL && m_orgbmp!=NULL) {
		m_dc->SelectObject(CBitmap::FromHandle(m_orgbmp));
	}

	if (m_dc!=NULL) {
		m_dc->DeleteDC();
	}

	if (m_hBMP!=0) {
		if (::DeleteObject(m_hBMP)==FALSE) {
			return -1;
		}
		m_hBMP=0;
	}
	if (m_dc!=NULL) {
		delete m_dc;
		m_dc=NULL;
	}
	if (m_bmi!=NULL) {
		free(m_bmi);
		m_bmi=NULL;
	}
	if (m_img!=NULL) {
		if (m_img->buff!=NULL) {
			free((void*)m_img->buff);	// 释放指针列
		}
		free((void*)m_img);
		m_img=NULL;
	}
	if (m_lut!=NULL) {
		if (m_lut->buff!=NULL) {
			free((void*)m_lut->buff);	// 释放指针列
		}
		free((void*)m_lut);
		m_lut=NULL;
	}

	return 0;
}

/*--------------------------------------------------------------------------
函数名	CDIB::CDIB

形式	CDIB::CDIB(void)

---------------------------------------------------------------------------*/
CDIB::CDIB()
{
	m_dc=NULL;
	m_bmi=NULL;
	m_img=NULL;
	m_lut=NULL;
	m_hBMP=0;
	m_orgbmp=0;
	m_color_type=IMG_UNDEFINED;
}

/*--------------------------------------------------------------------------
函数名	CDIB::~CDIB

形式	virtual CDIB::~CDIB()

---------------------------------------------------------------------------*/
CDIB::~CDIB()
{
	if (freeMember()!=0) {
	}
}

/*--------------------------------------------------------------------------
函数名	CDIB::create

形式	int CDIB::create(int w, int h, int nbit, int lut_type)
		int w, h;		// 图像宽和高	
		int nbit;		// 1个像素的bit数
		int lut_type;	// LUT类型(省略时:0/BI_RGB)丅
---------------------------------------------------------------------------*/
int CDIB::create(int w, int h, int nbit, int lut_type)
{
	int i;
	int colors;

//----------------------------------------------------
//	check参数
	if (w<=0) {
		return -1;
	}
	if (h<=0) {
		return -1;
	}
	if (nbit!=1 && nbit!=8 && nbit!=16 && nbit!=24 && nbit!=32) {
		return -1;
	}

//----------------------------------------------------
//	既有的对象释放
	if (m_dc!=NULL) {
		if (freeMember()!=0) {
			return -1;
		}
	}

//----------------------------------------------------
//	BITMAPINFO结构体生成
	if (nbit==1 || nbit==8) {
		if (nbit==1)		colors=2;
		else if (nbit==8)	colors=256;
		m_bmi=(BITMAPINFO*)malloc(sizeof(BITMAPINFOHEADER)+
										sizeof(RGBQUAD)*colors);
		if (m_bmi==NULL) {
			return -1;
		}
	} else if ((nbit==16 || nbit==32) && lut_type==BI_BITFIELDS) {
		m_bmi=(BITMAPINFO*)malloc(sizeof(BITMAPINFOHEADER)+sizeof(DWORD)*3);
		if (m_bmi==NULL) {
			return -1;
		}

	} else {
		m_bmi=(BITMAPINFO*)malloc(sizeof(BITMAPINFO));
		if (m_bmi==NULL) {
			return -1;
		}
	}
	m_bmi->bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
	m_bmi->bmiHeader.biWidth=w;
	m_bmi->bmiHeader.biHeight=-h;
	m_bmi->bmiHeader.biPlanes=1;
	m_bmi->bmiHeader.biBitCount=nbit;
	if ((nbit==16 || nbit==32) && lut_type==BI_BITFIELDS)
		m_bmi->bmiHeader.biCompression=BI_BITFIELDS;
	else
		m_bmi->bmiHeader.biCompression=BI_RGB;
	m_bmi->bmiHeader.biSizeImage=((w*nbit+31)/32)*4*h;
	m_bmi->bmiHeader.biXPelsPerMeter=2834;
	m_bmi->bmiHeader.biYPelsPerMeter=2834;
	m_bmi->bmiHeader.biClrUsed=0;
	m_bmi->bmiHeader.biClrImportant=0;
	if (nbit==1) {
		((RGBQUAD*)(m_bmi->bmiColors)+0)->rgbRed=0;
		((RGBQUAD*)(m_bmi->bmiColors)+0)->rgbGreen=0;
		((RGBQUAD*)(m_bmi->bmiColors)+0)->rgbBlue=0;
		((RGBQUAD*)(m_bmi->bmiColors)+0)->rgbReserved=0;
		((RGBQUAD*)(m_bmi->bmiColors)+1)->rgbRed=255;
		((RGBQUAD*)(m_bmi->bmiColors)+1)->rgbGreen=255;
		((RGBQUAD*)(m_bmi->bmiColors)+1)->rgbBlue=255;
		((RGBQUAD*)(m_bmi->bmiColors)+1)->rgbReserved=0;
	} else if (nbit==8) {
		if (lut_type==1) {
			for (i=0 ; i<256 ; i++) {
				((RGBQUAD*)(m_bmi->bmiColors)+i)->rgbRed=255-i;
				((RGBQUAD*)(m_bmi->bmiColors)+i)->rgbGreen=255-i;
				((RGBQUAD*)(m_bmi->bmiColors)+i)->rgbBlue=255-i;
				((RGBQUAD*)(m_bmi->bmiColors)+i)->rgbReserved=0;
			}
		} else {
			for (i=0 ; i<256 ; i++) {
				((RGBQUAD*)(m_bmi->bmiColors)+i)->rgbRed=i;
				((RGBQUAD*)(m_bmi->bmiColors)+i)->rgbGreen=i;
				((RGBQUAD*)(m_bmi->bmiColors)+i)->rgbBlue=i;
				((RGBQUAD*)(m_bmi->bmiColors)+i)->rgbReserved=0;
			}
		}
	} else if (nbit==16 && lut_type==BI_BITFIELDS) {
		*((DWORD*)(m_bmi->bmiColors)  )=0x00007C00;	// RedMask
		*((DWORD*)(m_bmi->bmiColors)+1)=0x000003E0;	// GreenMask
		*((DWORD*)(m_bmi->bmiColors)+2)=0x0000001F;	// BlueMask
	} else if (nbit==32 && lut_type==BI_BITFIELDS) {
		*((DWORD*)(m_bmi->bmiColors)  )=0x00FF0000;	// RedMask
		*((DWORD*)(m_bmi->bmiColors)+1)=0x0000FF00;	// GreenMask
		*((DWORD*)(m_bmi->bmiColors)+2)=0x000000FF;	// BlueMask
	}

//----------------------------------------------------
//	图像数据实体用impImage的生成
	m_img=(impImage*)malloc(sizeof(impImage));
	if (m_img==NULL) {
		freeMember();
		return -1;
	}
	m_img->w=w;
	m_img->h=h;
	m_img->nbit=(short)nbit;
	if (nbit==1 || nbit==8)		m_img->band=1;
	else if (nbit==32)			m_img->band=4;
	else						m_img->band=3;
	m_img->x_len=(int)((w*nbit+31)/32)*4;
	m_img->buff=(void**)malloc(sizeof(void*)*h);
	if (m_img->buff==NULL) {
		freeMember();
		return -1;
	}

//----------------------------------------------------
//	调色板用impImage的生成
	if (nbit==1 || nbit==8) {
		m_lut=(impImage*)malloc(sizeof(impImage));
		if (m_lut==NULL) {
			freeMember();
			return -1;
		}
		m_lut->w=1;
		m_lut->h=colors;
		m_lut->nbit=32;
		m_lut->band=4;
		m_lut->x_len=(int)((32+31)/32)*4;
		m_lut->buff=(void**)malloc(sizeof(void*)*m_lut->h);
		if (m_lut->buff==NULL) {
			freeMember();
			return -1;
		}
	}

//----------------------------------------------------
//	DeviceContext的生成和与DIB的连接
	BYTE *dib;

	m_dc=new CDC();
	if (m_dc==NULL) {
		freeMember();
		return -1;
	}
	if (m_dc->CreateCompatibleDC(NULL)==FALSE) {
		freeMember();
		return -1;
	}
	m_hBMP=CreateDIBSection(m_dc->GetSafeHdc(), m_bmi, DIB_RGB_COLORS,(void**)&dib, NULL, 0);
	if (m_hBMP==NULL) {
		freeMember();
		return -1;
	}

//----------------------------------------------------
//	DIB领域与图像结构体相连接
	for (i=0 ; i<h ; i++, dib+=m_img->x_len) {
		*(m_img->buff+i)=dib;
	}
	if (nbit==1 || nbit==8) {
		for (i=0 ; i<colors ; i++) {
			*(m_lut->buff+i)=(RGBQUAD*)(m_bmi->bmiColors)+i;
		}
	}

//----------------------------------------------------
//	BMP对象的选择
	m_orgbmp=(HBITMAP)(m_dc->SelectObject(CBitmap::FromHandle(m_hBMP)));
	if (m_orgbmp==0) {
		freeMember();
		return -1;
	}

//----------------------------------------------------
//	色彩空间种类的设定
	if (nbit==1 || nbit==8)		m_color_type=IMG_GRAY;
	else						m_color_type=IMG_RGB;
	return 0;
}




/*--------------------------------------------------------------------------
函数名	CDIB::isGray

形式	BOOL CDIB::isGray()
---------------------------------------------------------------------------*/
BOOL CDIB::isGray()
{
	int clen, i;

	if (m_img->nbit!=1 && m_img->nbit!=8)	return FALSE;

	clen=m_bmi->bmiHeader.biClrUsed;
	if (clen==0) {
		if (m_img->nbit==1)			clen=2;
		else if (m_img->nbit==8)	clen=256;
	}
	for (i=0 ; i<clen ; i++) {
		if (m_bmi->bmiColors[i].rgbRed!=m_bmi->bmiColors[i].rgbGreen ||
			m_bmi->bmiColors[i].rgbRed!=m_bmi->bmiColors[i].rgbBlue) {
			return FALSE;
		}
	}
	return TRUE;
}

//-----------------------------------------------------------------
//
int CDIB::copyObject(CDIB &src)
{
    int w, h, nbit;
    if (&src==NULL)	return 0;

    w=src.getDIB()->w;
    h=src.getDIB()->h;
    nbit=src.getDIB()->nbit;
    if (create(w, h, nbit)!=0) {
    	return -1;
    }

    int buff_size=src.getDIB()->x_len*h;
    memcpy(*(m_img->buff), *(src.getDIB()->buff), buff_size);

    impImage *lut=src.getLUT();
    if (lut!=NULL) {
	buff_size=lut->x_len*lut->h;
	memcpy(*(m_lut->buff), *(lut->buff), buff_size);
    }

    m_color_type=src.colorType();

    return 0;
}

//-----------------------------------------------------------------
// 
CDIB &CDIB::operator=(
    CDIB &src)  
{
    //if (copyObject(src)!=0) {
    //}
    copyObject(src);
    return *this;
}