image.cpp

这是一个实现Adaboost算法的程序

        TRY {
                pFile->Read(m_pData, dwFileLength);
        }
        CATCH (CFileException, e) {
                AfxMessageBox("Read error");
                GlobalFreePtr(m_pDib);  // free the DIB memory
                return FALSE;
        }
        END_CATCH

                SetDIB(true);
        Dib();
        return TRUE;
}

BOOL CImage::ReadFromDAT(CFile* pFile)
{
        LPBITMAPINFOHEADER pBMIH;
        DWORD dwFileLength = pFile->GetLength();
        WORD w,h;
        ///////just for MIT facebase!!!
        w = 256;
        h = 240;
        //w = 128;
        //h = 120;
        //for bern faces
        w = 512;
        h = 342;

        if(dwFileLength <= (DWORD)(w * h))
        {
                AfxMessageBox("Wrong Data!");
                return false;
        }

        DWORD dwBytes = Transform(w);//bytes per line

        m_dwLength = DWORD(dwBytes * h) + sizeof(BITMAPINFOHEADER)
                + sizeof(RGBQUAD) * 256;
        if (!AllocateMemory()) {
                AfxMessageBox("Allocmemory Error");
                return FALSE;}

        pBMIH=BMInfoHdPtr();
        pBMIH->biSize = sizeof(BITMAPINFOHEADER);
        pBMIH->biWidth = w;
        pBMIH->biHeight = h;
        pBMIH->biPlanes = 1;
        pBMIH->biBitCount = 8;
        pBMIH->biCompression = BI_RGB;
        pBMIH->biSizeImage = 0;
        pBMIH->biXPelsPerMeter = 0;
        pBMIH->biYPelsPerMeter = 0;
        pBMIH->biClrUsed = 0;
        pBMIH->biClrImportant = 0;
        m_pData = (BYTE*) m_pDib + sizeof(BITMAPINFOHEADER) +
                sizeof(RGBQUAD) * NumColors();
        CreateGreyPalette();

        //for bern faces
        pFile->Seek(32L, CFile::begin);

        TRY {
                pFile->Read(m_pData, (long(w) * h));
        }
        CATCH (CFileException, e) {
                AfxMessageBox("Read error");
                GlobalFreePtr(m_pDib);  // free the DIB memory
                return FALSE;
        }
        END_CATCH

                SetDIB(false);
        Dib();
        return TRUE;
}
/////////////////the property of the image////////////////
/////////Mean grey value
BYTE	CImage::MeanGrey()
{
        BYTE	avegrey;
        double sum = 0.0;
        DWORD i, imgsize;
        imgsize = (DWORD) Width() * Height();
        BYTE*	pData = Data();
        for(i=0;i<imgsize;i++)
                sum += pData[i];
        avegrey = (BYTE)(sum / imgsize);
        Dib();
        return avegrey;
}


double	CImage::CleanMeasure()
{
        double	diff	=	0.0;
        DWORD	i;
        BYTE	mean	=	MeanGrey();
        BYTE*	pData	=	Data();
        DWORD	imgSize	=	Width() * Height();
        for(i=0,diff=0.0; i<imgSize; i++)
                diff += (pData[i] - mean) * (pData[i] - mean);
        diff = sqrt(diff) / imgSize;
        Dib();
        return diff;
}

BYTE	CImage::Get8NeiborAver(BYTE* pGreyData, WORD w, WORD h, CPoint pos)
{
        double temp;
        int x = pos.x;
        int y = pos.y;
        int t = y * w + x;
        if(x == 0 && y != 0)
        {
                temp  =	pGreyData[t-w] + pGreyData[t-w+1] +
                        pGreyData[t+1] + 
                        pGreyData[t+w] + pGreyData[t+w+1];
                temp /= 5;
                return (BYTE)temp;
        }
        if(x != 0 && y == 0)
        {
                temp  =	pGreyData[t-1] + pGreyData[t+1] + 
                        pGreyData[t+w-1] + pGreyData[t+w] + pGreyData[t+w+1];
                temp /= 5;
                return (BYTE)temp;
        }
        if(x == 0 && y != 0)
        {
                temp  =	pGreyData[t+1] +
                        pGreyData[t+w] + pGreyData[t+w+1];
                temp /= 3;
                return (BYTE)temp;
        }

        if(x == w-1 && y != h-1)
        {
                temp  =	pGreyData[t-w-1] + pGreyData[t-w] +
                        pGreyData[t-1] + 
                        pGreyData[t+w-1] + pGreyData[t+w];
                temp /= 5;
                return (BYTE)temp;
        }
        if(x != w-1 && y == h-1)
        {
                temp  =	pGreyData[t-w-1] + pGreyData[t-w] + pGreyData[t-w+1] +
                        pGreyData[t-1] + pGreyData[t+1];
                temp /= 5;
                return (BYTE)temp;
        }
        if(x = w-1 && y == h-1)
        {
                temp  =	pGreyData[t-w-1] + pGreyData[t-w] + 
                        pGreyData[t-1];
                temp /= 3;
                return (BYTE)temp;
        }
        temp  =	pGreyData[t-w-1] + pGreyData[t-w] + pGreyData[t-w+1] +
                pGreyData[t-1]   + pGreyData[t+1] +
                pGreyData[t+w-1] + pGreyData[t+w] + pGreyData[t+w+1];
        temp /= 8;
        return (BYTE)temp;
}


///////////////////////////////////////////////
/*
* SSG, 1999.6. 2
* Save the data as text
*/
///////////////////////////////////////////////
BOOL CImage::SaveAsText(CString	 filename, BOOL	bIsBinary)
{
        int		w;
        long	l, size;
        char	buf[20];
        CFile	f;
        BYTE	*pData;

        pData = Data();

        if (m_pDib == NULL)
                return FALSE;
        if(Bits() != 8) {
                AfxMessageBox("It is not 8-greylevel image!");		
                return false;	
        }
        w = Width();
        size = w * Height();

        f.Open(filename, CFile::modeCreate | CFile::modeWrite );
        if(bIsBinary)
        {
                for(l=0; l<size; l++)
                {
                        if(*(pData + l) != 0)
                                sprintf(buf, "*");
                        else
                                sprintf(buf, ".");
                        f.Write(buf, strlen(buf));
                        if( (l+1)%w == 0){
                                f.Write("\n", 1);
                        }
                }
        }
        else
        {
                for(l=0; l<size; l++)
                {
                        sprintf(buf, "%3d ", *(pData + l) );
                        f.Write(buf, strlen(buf));
                        if( (l+1)%w == 0){
                                f.Write("\n", 1);
                        }
                }
        }
        f.Close();

        Dib();
        return TRUE;
}

BOOL CImage::ValidImage()
{
        if(m_dwLength == 0L || m_pData == NULL || m_pDib == NULL)
                return FALSE;
        else
                return TRUE;
}

/********************************************************************
///////////////////////////from the CImage///////////////////
********************************************************************/



BOOL CImage::Convert2I_Image()
{
        if(Bits() != 24)
                return FALSE;

        int		w = Width();
        int		h = Height();

        CImage	*pI_Img = new CImage(CSize(w, h), 256, 8);

        BYTE		*pI_Data = pI_Img->Data();
        BYTE		*pColorData = Data();

        long		size, l;
        double		I, Q;
        BYTE		R, G, B, Y;
        size = long(Width() * Height());
        for(l=0; l<size; l++)
        {
                B = *pColorData++;
                G = *pColorData++;
                R = *pColorData++;
                RGB2YIQ(R, G, B, Y, I, Q);
                *pI_Data++ = BYTE( I );
        }

        pI_Data = pI_Img->Dib();
        *this = *pI_Img;
        delete pI_Img;

        return TRUE;
}

BOOL CImage::GetRImage(CImage * pRImg)
{
        if(Bits() != 24)
                return FALSE;

        int		w = Width();
        int		h = Height();

        BYTE		*pRData = pRImg->Data();
        BYTE		*pColorData = Data();

        long		size, l;
        size = long(Width() * Height() * 3);

        for(l=0; l<size; l+=3)
                *pRData++ = *(pColorData+l+2);

        Dib();
        pRImg->Dib();

        return TRUE;
}

BOOL CImage::GetGImage(CImage * pGImg)
{
        if(Bits() != 24)
                return FALSE;

        int		w = Width();
        int		h = Height();

        BYTE		*pGData = pGImg->Data();
        BYTE		*pColorData = Data();

        long		size, l;
        size = long(Width() * Height() * 3);

        for(l=0; l<size; l+=3)
                *pGData++ = *(pColorData+l+1);

        Dib();
        pGImg->Dib();

        return TRUE;
}

BOOL CImage::GetBImage(CImage * pBImg)
{
        if(Bits() != 24)
                return FALSE;

        int		w = Width();
        int		h = Height();

        BYTE		*pBData = pBImg->Data();
        BYTE		*pColorData = Data();

        long		size, l;
        size = long(Width() * Height() * 3);

        for(l=0; l<size; l+=3)
                *pBData++ = *(pColorData+l);

        Dib();
        pBImg->Dib();

        return TRUE;
}

/*
* return paras:
* pfr:  f(u,v) 实部
* pfi:  f(u,v) 虚部
* pfm:  模
* pfa:  幅角
*/


BOOL CImage::CenterRotateInImagePlane(double angle, BOOL bClockWise)
{
        double	radianAngle;
        double	oldx, oldy;
        double  cofX, cofY, FTmp;
        double  SinCita, CosCita;
        int		i, j, x1;
        long	w, h, ImageSize;

        w = Width();
        h = Height();
        ImageSize = (long)w*h;

        CPoint fixpos = CPoint(w/2, h/2);
        if(bClockWise)
                radianAngle = angle*3.1415926/180.0;
        else
                radianAngle = -angle*3.1415926/180.0;
        SinCita = sin(radianAngle);
        CosCita = cos(radianAngle);

        CImage* pTempImg = new CImage;
        *pTempImg = *this;

        BYTE* pOriData = Data();
        BYTE* pNewData = pTempImg->Data();

        double t1, t2;
        long t3 = 0;
        for(j=0; j<h; j++)
        {
                t1 = SinCita * (j - fixpos.y);
                t2 = CosCita * (j - fixpos.y);
                t3 = j * w;
                for(i=0; i<w; i++)
                {
                        oldx = fixpos.x +  (CosCita * (i - fixpos.x) + t1);
                        oldy = fixpos.y +  (t2 - SinCita * (i - fixpos.x));
                        if(oldx < w-1 && oldy < h-1 && oldx >= 0 && oldy >= 0)
                        {	
                                cofX = oldx - int(oldx);
                                cofY = oldy - int(oldy);
                                x1 = ((int)oldy) * w + (int)oldx;
                                FTmp = (1-cofX) * (double)pOriData[x1] + cofX * (double)pOriData[x1 + 1];
                                FTmp = (1-cofY) * FTmp + cofY * ((1-cofX) * (double)pOriData[x1 + w] + cofX * (double)pOriData[x1 + w + 1]);
                                pNewData[j * w + i] = int (FTmp + 0.5);
                        }
                        else 
                                pNewData[j * w + i] = 0;
                }
        }

        pTempImg->Dib();
        *this = *pTempImg;
        Dib();
        delete pTempImg;
        return true;

}


DWORD CImage::ByteNumForOneLine(WORD nDIBWidth, int nBpp)
{
        DWORD dwBytes = (nDIBWidth * nBpp) / 32;
        if ((nDIBWidth * nBpp) % 32) 
                dwBytes ++;

        dwBytes *= 4;//bytes per line

        return	dwBytes;
}