Пример #1
0
HDIB  CxDib::Create(DWORD dwWidth, DWORD dwHeight, WORD wBitCount)
{
    LPBITMAPINFOHEADER  lpbi;	// pointer to BITMAPINFOHEADER
    DWORD               dwLen;	// size of memory block

	if (hDib) free(hDib);
	hDib=NULL;

    // Make sure bits per pixel is valid
    if (wBitCount <= 1)			wBitCount = 1;
    else if (wBitCount <= 4)	wBitCount = 4;
    else if (wBitCount <= 8)	wBitCount = 8;
    else				        wBitCount = 24;

    switch (wBitCount){
        case 1:
            m_nColors = 2;
			break;
        case 4:
            m_nColors = 16;
			break;
        case 8:
            m_nColors = 256;
			break;
        default:
            m_nColors = 0;
    }

    m_LineWidth = WIDTHBYTES(wBitCount * dwWidth);

    // initialize BITMAPINFOHEADER
    m_bi.biSize = sizeof(BITMAPINFOHEADER);
    m_bi.biWidth = dwWidth;         // fill in width from parameter
    m_bi.biHeight = dwHeight;       // fill in height from parameter
    m_bi.biPlanes = 1;              // must be 1
    m_bi.biBitCount = wBitCount;    // from parameter
    m_bi.biCompression = BI_RGB;    
    m_bi.biSizeImage = m_LineWidth * dwHeight;
    m_bi.biXPelsPerMeter = 0;
    m_bi.biYPelsPerMeter = 0;
    m_bi.biClrUsed = 0;
    m_bi.biClrImportant = 0;

    // calculate size of memory block required to store the DIB.  This
    // block should be big enough to hold the BITMAPINFOHEADER, the color
    // table, and the bits
    dwLen = GetSize();

	//hDib = malloc(dwLen); // alloc memory block to store our bitmap
	hDib = new (HDIB[dwLen]); //fixes allocation problem under Win2k
    if (!hDib) return NULL;

    // use our bitmap info structure to fill in first part of
    // our DIB with the BITMAPINFOHEADER
	lpbi = (LPBITMAPINFOHEADER)(hDib);
    *lpbi = m_bi;

    return hDib; //return handle to the DIB
}
Пример #2
0
bool CImageObject::LoadImageBMP( char *filename )
{

	BITMAPFILEHEADER bmFileHeader;
	BITMAPINFOHEADER bmInfoHeader;
	
		
	CFile file;
	if (!file.Open(filename, CFile::modeNoTruncate | CFile::modeRead ))  
	{
		printf("No file %s", filename);
		return false;
	}
	file.Read(&bmFileHeader, sizeof(BITMAPFILEHEADER));
	file.Read(&bmInfoHeader, sizeof(BITMAPINFOHEADER));

	m_ImageWidth = bmInfoHeader.biWidth;
	m_ImageHeight = abs(bmInfoHeader.biHeight);
	int bytespixel_src = bmInfoHeader.biBitCount/8;

	BYTE *PixelFlip = new BYTE[m_ImageHeight * m_ImageWidth * bytespixel_src];

	file.Read(PixelFlip, m_ImageHeight * m_ImageWidth * bytespixel_src);
	file.Close();
		
	

	
	
	if (m_rgb_pixel != NULL)	
		delete m_rgb_pixel;

	if (m_display_pixel != NULL)	
		delete m_display_pixel;

	

	int widthbytes_display = WIDTHBYTES(m_ImageWidth,bmInfoHeader.biBitCount);

	m_rgb_pixel = new BYTE[m_ImageHeight * m_ImageWidth * 3];

	// Loading Flip BMP image
	for (int row=0;row<m_ImageHeight;row++)
	{
		for (int col=0;col<m_ImageWidth;col++)
		{
			m_rgb_pixel[3 * ((m_ImageHeight - row - 1)*m_ImageWidth+col)    ]	= PixelFlip[(row*widthbytes_display + col*bytespixel_src) + 0];
			m_rgb_pixel[3 * ((m_ImageHeight - row - 1)*m_ImageWidth+col) + 1] = PixelFlip[(row*widthbytes_display + col*bytespixel_src) + 1];
			m_rgb_pixel[3 * ((m_ImageHeight - row - 1)*m_ImageWidth+col) + 2] = PixelFlip[(row*widthbytes_display + col*bytespixel_src) + 2];

		}
	}
	
	//delete temp2;
	delete [] PixelFlip;
	return true;
	// Invalidate(FALSE);
}
Пример #3
0
//handles copying the image data from the associated bitmap to the 16 bit texture provided
static void CopyGlyphBitmapToPixelData( BITMAPINFO const& bmi, uint8 const* pDibBits, 
									   const LTRect2n& rectDest,
									   TEXTMETRICW const& textMetric,
									   uint8* pPixelData, SIZE const& sizeTexture )
{
	//pitches of each surface
	const int nBitmapPitch = WIDTHBYTES( bmi.bmiHeader.biBitCount, bmi.bmiHeader.biWidth );
	const int nPixelDataPitch = WIDTHBYTES( 16, sizeTexture.cx );

	//pixel byte widths of the bitmap surface
	const int nBitmapPixelWidth = (bmi.bmiHeader.biBitCount + 7) / 8;

	//calculate the width
	const int nGlyphWidth = rectDest.GetWidth();

	//calcualte the height
	const int nGlyphHeight = rectDest.GetHeight();

	// Copy the glyph pixels to the pixeldata.  Leave the rgb of the pixeldata set to white.
	// This lets the font antialias with any color background.
	for( int y = 0; y < nGlyphHeight; y++ )
	{
		// Find out where to start this row by offset by y using the passed in bitmap pitch.
		// We only need to copy the glyph pixels, so we advance into the bitmap to
		// where they start.  The source is 24 bpp.
		const uint8* pSrcPos = pDibBits + ( y * nBitmapPitch );

		// The pixeldata pointer will be pointing to some region in 
		// the middle of a larger bitmap.  So, we use the pixeldatapitch
		// passed in to calculate how much to advance per line.  We don't want
		// to write out any columns to the left or right of the actual glyph.
		uint16* pDestPos = ( uint16* )( pPixelData + (( y + rectDest.Top() ) * nPixelDataPitch ) + (rectDest.Left() * 2) );

		// Copy this row.
		for( int x = 0; x < nGlyphWidth; x++ )
		{
			// The source is 24 bits.  Just take r and use it as the alpha value.
			uint32 nVal = MulDiv( pSrcPos[0], 15, 255 );
			*pDestPos = ( *pDestPos & 0x0FFF ) | (( nVal & 0x0F ) << 12 );

			pDestPos++;
			pSrcPos += nBitmapPixelWidth;
		}
	}
}
Пример #4
0
char* LoadJpegFile (char *jpegbuf, char *bmpbuf)
{
	DWORD 		       ImgSize;
	DWORD              JpegBufSize;
	int				   funcret;
	LPBITMAPINFOHEADER lpImgData;
	//JpegBufSize=size;
	lpJpegBuf=jpegbuf;
	InitTable();
	if((funcret=InitTag())!=FUNC_OK)
	{
		showerror(funcret);
		return NULL;
	}
	//create new bitmapfileheader and bitmapinfoheader
	memset((char *)&bf,0,sizeof(BITMAPFILEHEADER));	
	memset((char *)&bi,0,sizeof(BITMAPINFOHEADER));

	bi.biSize=(DWORD)sizeof(BITMAPINFOHEADER);
	bi.biWidth=(LONG)(ImgWidth);
	bi.biHeight=(LONG)(ImgHeight);
	bi.biPlanes=1;
	bi.biBitCount=24;
	bi.biClrUsed=0;
	bi.biClrImportant=0;
	bi.biCompression=BI_RGB;
	NumColors=0;
	LineBytes=(DWORD)WIDTHBYTES(bi.biWidth*bi.biBitCount);
	ImgSize=(DWORD)LineBytes*bi.biHeight;
	
	bf.bfType=0x4d42;
	bf.bfSize=/*sizeof(BITMAPFILEHEADER)*/ 14+sizeof(BITMAPINFOHEADER)+NumColors*sizeof(RGBQUAD)+ImgSize;
	bf.bfOffBits=(DWORD)(NumColors*sizeof(RGBQUAD)+14/*sizeof(BITMAPFILEHEADER)*/+sizeof(BITMAPINFOHEADER));

	lpPtr = (char*)bmpbuf + 54;

	if((SampRate_Y_H==0)||(SampRate_Y_V==0))
	{
		showerror(FUNC_FORMAT_ERROR);
		return NULL ;
	}

	funcret=Decode();

	memcpy(bmpbuf, &bf.bfType,sizeof(WORD));
	memcpy(bmpbuf+2, ((char*)&bf)+4, 12);
	memcpy(bmpbuf+14, (LPSTR)&bi,sizeof(BITMAPINFOHEADER));

	if(funcret!=FUNC_OK)
	{
		showerror(funcret);
		return NULL;
	}
	return lpPtr;
}
Пример #5
0
/****************************************************************************
*
*     FUNCTION: DIBToIconImage
*
*     PURPOSE:  Converts a CF_DIB memory block to an icon image
*
*     PARAMS:   LPICONIMAGE lpii          - pointer to icon image data
*               LPBYTE      lpDIB         - a pointer to the CF_DIB block
*               BOOL        bStretchToFit - TRUE to stretch, FALSE to take
*                                           the upper left corner of the DIB
*
*     RETURNS:  BOOL - TRUE for success, FALSE for failure
*
* History:
*                July '95 - Created
*
\****************************************************************************/
BOOL DIBToIconImage( LPICONIMAGE lpii, LPBYTE lpDIB, BOOL bStretch )
{
    LPBYTE    	lpNewDIB;

    // Sanity check
    if( lpDIB == NULL )
        return FALSE;

    // Let the DIB engine convert color depths if need be
    lpNewDIB = ConvertDIBFormat( (LPBITMAPINFO)lpDIB, lpii->Width, lpii->Height, lpii->Colors, bStretch );

    // Now we have a cool new DIB of the proper size/color depth
    // Lets poke it into our data structures and be done with it

    // How big is it?
    lpii->dwNumBytes = sizeof( BITMAPINFOHEADER )                    	// Header
                    + PaletteSize( (LPSTR)lpNewDIB )                    // Palette
                    + lpii->Height * BytesPerLine( (LPBITMAPINFOHEADER)lpNewDIB )	// XOR mask
                    + lpii->Height * WIDTHBYTES( lpii->Width );        	// AND mask

    // If there was already an image here, free it
    if( lpii->lpBits != NULL )
        free( lpii->lpBits );
    // Allocate enough room for the new image
    if( (lpii->lpBits = malloc( lpii->dwNumBytes )) == NULL )
    {
        free( lpii );
        return FALSE;
    }
    // Copy the bits
    memcpy( lpii->lpBits, lpNewDIB, sizeof( BITMAPINFOHEADER ) + PaletteSize( (LPSTR)lpNewDIB ) );
    // Adjust internal pointers/variables for new image
    lpii->lpbi = (LPBITMAPINFO)(lpii->lpBits);
    lpii->lpbi->bmiHeader.biHeight *= 2;
    lpii->lpXOR = FindDIBBits( (LPSTR)(lpii->lpBits) );
    memcpy( lpii->lpXOR, FindDIBBits((LPSTR)lpNewDIB), lpii->Height * BytesPerLine( (LPBITMAPINFOHEADER)lpNewDIB ) );
    lpii->lpAND = lpii->lpXOR + lpii->Height * BytesPerLine( (LPBITMAPINFOHEADER)lpNewDIB );
    memset( lpii->lpAND, 0, lpii->Height * WIDTHBYTES( lpii->Width ) );
    // Free the source
    free( lpNewDIB );
    return TRUE;
}
Пример #6
0
HANDLE AllocRoomForDIB(BITMAPINFOHEADER bi, HBITMAP hBitmap)
{
    DWORD              dwLen;
    HANDLE             hDIB;
    HDC                hDC;
    LPBITMAPINFOHEADER lpbi;
    HANDLE             hTemp;

    /* Figure out the size needed to hold the BITMAPINFO structure
     * (which includes the BITMAPINFOHEADER and the color table).
     */

    dwLen = bi.biSize + PaletteSize((LPSTR) &bi);
    hDIB  = GlobalAlloc(GHND,dwLen);

    /* Check that DIB handle is valid */
    if (!hDIB)
        return NULL;

    /* Set up the BITMAPINFOHEADER in the newly allocated global memory,
     * then call GetDIBits() with lpBits = NULL to have it fill in the
     * biSizeImage field for us.
     */
    lpbi  = (VOID FAR *)GlobalLock(hDIB);
    *lpbi = bi;

    hDC   = GetDC(NULL);
    GetDIBits(hDC, hBitmap, 0, (WORD) bi.biHeight,
              NULL, (LPBITMAPINFO) lpbi, DIB_RGB_COLORS);
    ReleaseDC(NULL, hDC);

    /* If the driver did not fill in the biSizeImage field,
     * fill it in -- NOTE: this is a bug in the driver!
     */
    if (lpbi->biSizeImage == 0)
        lpbi->biSizeImage = WIDTHBYTES((DWORD)lpbi->biWidth * lpbi->biBitCount) *
                            lpbi->biHeight;

    /* Get the size of the memory block we need */
    dwLen = lpbi->biSize + PaletteSize((LPSTR) &bi) + lpbi->biSizeImage;

    /* Unlock the memory block */
    GlobalUnlock(hDIB);

    /* ReAlloc the buffer big enough to hold all the bits */
    if (hTemp = GlobalReAlloc(hDIB,dwLen,0))
        return hTemp;
    else
    {
        /* Else free memory block and return failure */
        GlobalFree(hDIB);
        return NULL;
    }
}
Пример #7
0
//在固定位置将点变为红色
void CIconOperate::SetPointColor(int x, int y, DWORD color)
{
	if(m_IconData == NULL || m_IconDir == NULL)
		return  ;

	if (x < 0 || x >= m_IconDir->idEntries[0].bwidth || y < 0 || y >= m_IconDir->idEntries[0].bheight )
		return ;

	int index = (y * WIDTHBYTES(m_IconDir->idEntries[0].bwidth,m_IconDir->idEntries[0].wbitcount) + x*4);
	*(DWORD*)(&m_IconData->data[0].icxor[index]) = color ;
}
Пример #8
0
// load jpeg file
BOOL CJpeg::Load(LPCSTR lpstrFileName)
{
	UINT uWidth, uHeight, uWidthDW;

	// read the jpeg to a packed buffer of RGB bytes
	BYTE *lpTmpBuffer = ReadJPEGFile(lpstrFileName, &uWidth, &uHeight);
	if (lpTmpBuffer == NULL)
		return FALSE;

	// do this before DWORD-alignment!!!
	// swap red and blue for display
	BGRFromRGB(lpTmpBuffer, uWidth, uHeight);

	// now DWORD-align for display
	BYTE *lpBuffer = MakeDwordAlign(lpTmpBuffer, uWidth, uHeight, &uWidthDW);
	FreeBuffer(lpTmpBuffer);

	// flip for display
	VertFlipBuf(lpBuffer, uWidthDW, uHeight);

	BITMAPINFOHEADER bmiHeader;
	bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	bmiHeader.biWidth = uWidth;
	bmiHeader.biHeight = uHeight;
	bmiHeader.biPlanes = 1;
	bmiHeader.biBitCount = 24;
	bmiHeader.biCompression = BI_RGB;
	bmiHeader.biSizeImage = 0;
	bmiHeader.biXPelsPerMeter = 0;
	bmiHeader.biYPelsPerMeter = 0;
	bmiHeader.biClrUsed = 0;
	bmiHeader.biClrImportant = 0;

    // Allocate enough memory for the new CF_DIB, and copy bits 
	DWORD dwHeaderSize = sizeof(BITMAPINFOHEADER);
	DWORD dwBitsSize = WIDTHBYTES(uWidth*24) * uHeight;
    HDIB hDIB = GlobalAlloc(GHND, dwHeaderSize + dwBitsSize); 
	if (hDIB == NULL)
		return FALSE;

    LPBYTE lpDIB = (LPBYTE)GlobalLock(hDIB); 
    memcpy(lpDIB, (LPBYTE)&bmiHeader, dwHeaderSize); 
    memcpy(FindDIBBits((LPBYTE)lpDIB), lpBuffer, dwBitsSize); 
	FreeBuffer(lpBuffer);

	if (m_pDib != NULL)
		delete m_pDib;

	m_pDib = new CDib();
	m_pDib->Attach(hDIB);

	return TRUE;
}
Пример #9
0
/****************************************************************************
*
*     FUNCTION: CreateBlankNewFormatIcon
*
*     PURPOSE:  Creates a blank icon image for a new format
*
*     PARAMS:   LPICONIMAGE lpii          - pointer to icon image data
*
*     RETURNS:  BOOL - TRUE for success, FALSE for failure
*
* History:
*                July '95 - Created
*
\****************************************************************************/
BOOL CreateBlankNewFormatIcon( LPICONIMAGE lpii )
{
    DWORD            	dwFinalSize;
    BITMAPINFOHEADER    bmih;

    // Fill in the bitmap header
    ZeroMemory( &bmih, sizeof( BITMAPINFOHEADER ) );
    bmih.biSize = sizeof( BITMAPINFOHEADER );
    bmih.biBitCount = lpii->Colors;
    bmih.biClrUsed = 0;
    
    // How big will the final thing be?
    // Well, it'll have a header
    dwFinalSize = sizeof( BITMAPINFOHEADER );
    // and a color table (even if it's zero length)
    dwFinalSize += PaletteSize( (LPSTR)&bmih );
    // and XOR bits
    dwFinalSize += lpii->Height * WIDTHBYTES( lpii->Width * lpii->Colors );
    // and AND bits. That's about it :)
    dwFinalSize += lpii->Height * WIDTHBYTES( lpii->Width );

    // Allocate some memory for it
    lpii->lpBits = malloc( dwFinalSize );
    ZeroMemory( lpii->lpBits, dwFinalSize );
    lpii->dwNumBytes = dwFinalSize;
    lpii->lpbi = (LPBITMAPINFO)(lpii->lpBits);
    lpii->lpXOR = (LPSTR)(lpii->lpbi) + sizeof(BITMAPINFOHEADER) + PaletteSize( (LPSTR)&bmih );
    lpii->lpAND = lpii->lpXOR + (lpii->Height * WIDTHBYTES( lpii->Width * lpii->Colors ));

    // The bitmap header is zeros, fill it out
    lpii->lpbi->bmiHeader.biSize = sizeof( BITMAPINFOHEADER ); 
    lpii->lpbi->bmiHeader.biWidth = lpii->Width;
    // Don't forget the funky height*2 icon resource thing
    lpii->lpbi->bmiHeader.biHeight = lpii->Height * 2; 
    lpii->lpbi->bmiHeader.biPlanes = 1; 
    lpii->lpbi->bmiHeader.biBitCount = lpii->Colors; 
    lpii->lpbi->bmiHeader.biCompression = BI_RGB; 
                   
    return TRUE;
}
Пример #10
0
/*
 * Get a strip-organized image that has
 *  PlanarConfiguration contiguous if SamplesPerPixel > 1
 * or
 *  SamplesPerPixel == 1
 *
 *  Hacked from the tif_getimage.c file.
 *
 *    This is set up to allow us to just copy the data to the raster
 *    for 1-bit bitmaps
 */
static int
getStripContig1Bit(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
{
    TIFF* tif = img->tif;
    tileContigRoutine put = img->put.contig;
    uint16 orientation;
    uint32 row, y, nrow, rowstoread;
    uint32 pos;
    u_char* buf;
    uint32 rowsperstrip;
    uint32 imagewidth = img->width;
    tsize_t scanline;
    int32 fromskew, toskew;
    tstrip_t strip;
    tsize_t  stripsize;
    u_char* braster = (u_char*)raster; // byte wide raster
    uint32  wb = WIDTHBYTES(w);
    int ret = 1;

    buf = (u_char*) _TIFFmalloc(TIFFStripSize(tif));
    if (buf == 0) {
        TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "No space for strip buffer");
        return (0);
    }
    y = setorientation(img, h);
    orientation = img->orientation;
    toskew = -(int32) (orientation == ORIENTATION_TOPLEFT ? wb+wb : wb-wb);
    TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
    scanline = TIFFScanlineSize(tif);
    fromskew = (w < imagewidth ? imagewidth - w : 0)/8;
    for (row = 0; row < h; row += nrow)
    {
        rowstoread = rowsperstrip - (row + img->row_offset) % rowsperstrip;
        nrow = (row + rowstoread > h ? h - row : rowstoread);
        strip = TIFFComputeStrip(tif,row+img->row_offset, 0);
        stripsize = ((row + img->row_offset)%rowsperstrip + nrow) * scanline;
        if (TIFFReadEncodedStrip(tif, strip, buf, stripsize ) < 0
            && img->stoponerr)
        {
            ret = 0;
            break;
        }

        pos = ((row + img->row_offset) % rowsperstrip) * scanline;
        (*put)(img, (uint32*)(braster+y*wb), 0, y, w, nrow, fromskew, toskew, buf + pos);
        y += (orientation == ORIENTATION_TOPLEFT ?-(int32) nrow : (int32) nrow);
    }
    _TIFFfree(buf);
    return (ret);
}
Пример #11
0
//
// copies BYTE buffer into DWORD-aligned BYTE buffer
// return addr of new buffer
//
BYTE * CJpeg::MakeDwordAlign(BYTE *dataBuf,
								 UINT widthPix,				// pixels!!
								 UINT height,
								 UINT *uiOutWidthBytes)		// bytes!!!
{
	////////////////////////////////////////////////////////////
	// what's going on here? this certainly means trouble 
	if (dataBuf==NULL)
		return NULL;

	////////////////////////////////////////////////////////////
	// how big is the smallest DWORD-aligned buffer that we can use?
	UINT uiWidthBytes;
	uiWidthBytes = WIDTHBYTES(widthPix * 24);

	DWORD dwNewsize=(DWORD)((DWORD)uiWidthBytes * 
							(DWORD)height);
	BYTE *pNew;

	////////////////////////////////////////////////////////////
	// alloc and open our new buffer
	pNew=(BYTE *)new BYTE[dwNewsize];
	if (pNew==NULL) {
		return NULL;
	}
	
	////////////////////////////////////////////////////////////
	// copy row-by-row
	UINT uiInWidthBytes = widthPix * 3;
	UINT uiCount;
	for (uiCount=0;uiCount < height;uiCount++) 
	{
		BYTE * bpInAdd;
		BYTE * bpOutAdd;
		ULONG lInOff;
		ULONG lOutOff;

		lInOff=uiInWidthBytes * uiCount;
		lOutOff=uiWidthBytes * uiCount;

		bpInAdd= dataBuf + lInOff;
		bpOutAdd= pNew + lOutOff;

		memcpy(bpOutAdd,bpInAdd,uiInWidthBytes);
	}

	*uiOutWidthBytes=uiWidthBytes;
	return pNew;
}
Пример #12
0
void GetPoints(int nWidth,int nHeight,BYTE *lpBits,BYTE *lpPoints)
{
	int x,y,p;
	int nByteWidth = WIDTHBYTES(nWidth*24); //nWidth*3;
	//if (nByteWidth%4) nByteWidth+=4-(nByteWidth%4);

	for(y=0;y<nHeight;y++)
	{
		for(x=0;x<nWidth;x++)
		{
			p=x*3+y*nByteWidth;
			lpPoints[x+y*nWidth]=(BYTE)(0.299*(float)lpBits[p+2]+0.587*(float)lpBits[p+1]+0.114*(float)lpBits[p]+0.1);
		}
	}
}
Пример #13
0
unsigned char * JpegFile::MakeJPG_DWORDAlignedBuf(unsigned char *dataBuf,
									 JPG_UINT widthPix,				// pixels!!
									 JPG_UINT height,
									 JPG_UINT *uiOutWidthBytes)		// bytes!!!
{
	////////////////////////////////////////////////////////////
	// what's going on here? this certainly means trouble 
	if (dataBuf==NULL)
		return NULL;

	////////////////////////////////////////////////////////////
	// how big is the smallest JPG_DWORD-aligned buffer that we can use?
	JPG_UINT uiWidthBytes;
	uiWidthBytes = WIDTHBYTES(widthPix * 24);

	JPG_DWORD dwNewsize=(JPG_DWORD)((JPG_DWORD)uiWidthBytes * 
							(JPG_DWORD)height);
	unsigned char *pNew;

	////////////////////////////////////////////////////////////
	// alloc and open our new buffer
	pNew=(unsigned char *)new unsigned char[dwNewsize];
	if (pNew==NULL) {
		return NULL;
	}
	
	////////////////////////////////////////////////////////////
	// copy row-by-row
	JPG_UINT uiInWidthBytes = widthPix * 3;
	JPG_UINT uiCount;
	for (uiCount=0;uiCount < height;uiCount++) {
		unsigned char * bpInAdd;
		unsigned char * bpOutAdd;
		JPG_ULONG lInOff;
		JPG_ULONG lOutOff;

		lInOff=uiInWidthBytes * uiCount;
		lOutOff=uiWidthBytes * uiCount;

		bpInAdd= dataBuf + lInOff;
		bpOutAdd= pNew + lOutOff;

		memcpy(bpOutAdd,bpInAdd,uiInWidthBytes);
	}

	*uiOutWidthBytes=uiWidthBytes;
	return pNew;
}
Пример #14
0
/*************************************************************************
  函数名称: SaperaToBmpFmt()
  功能描述: 将图像数据从Sapera格式转换到BMP格式

  输入参数:         
            无 
            
  输出参数:
            无 

  返 回 值:
            TRUE:转换成功 FALSE:转换失败(不支持的数据格式)

  其它说明:
            BMP格式数据组织方式和Sapera的不同,BMP格式数据从下到上排列,且每行
            字节数为4的倍数,Sapera格式数据从上到下,每行字节数为实际宽度对应
            字节数。但GDI显示时只支持BMP格式,为了便于其他项目组直接使用算法库,
            故作此转换。此外,Sapera格式数据也是算法库采用的格式。    

  作    者: 周明才
  编写时间: 2005.12.16
*************************************************************************/
BOOL CMyDib::SaperaToBmpFmt()
{
	WORD wBitCount;  // DIB bit count
	wBitCount = m_pBMI->bmiHeader.biBitCount;

	switch (wBitCount) //只处理8位、24位和32位图像
	{
		case 8:
		case 24:
		case 32:
			break;
		default:
			return FALSE;
	}

    int     iWidth  = Width();
    int     iHeight = Height();
    int     iLineBytes;          //每行字节数(BMP格式)
    int     iWidthBytes;         //每行字节数(Sapera格式)
    UINT    nCount;              //BMP格式数据大小(BMP格式)
    LPBYTE  pbyDataCpy, pbyTmpRes, pbyTmpDst;

    // Calculate the number of bytes per line
    iLineBytes  = WIDTHBYTES(wBitCount * Width());
	nCount      = iLineBytes * iHeight;

    iWidthBytes = (wBitCount * Width()) / 8;

    pbyDataCpy  = new BYTE[nCount];
    memcpy(pbyDataCpy, m_pBits, nCount);        //为简单起见,做一份拷贝,

    int j;

    pbyTmpDst   = m_pBits + nCount - iLineBytes;
    pbyTmpRes   = pbyDataCpy;

    //从pbyDataCpy的底部开始取各行数据,对m_pBits从顶部开始填充。
    for (j=0; j<iHeight; j++) 
    {
        memcpy(pbyTmpDst, pbyTmpRes, iWidthBytes);
        pbyTmpDst -= iLineBytes;
        pbyTmpRes += iWidthBytes;
    }

    delete [] pbyDataCpy;
    return TRUE;
}
Пример #15
0
doublemap_t *doublemap_create(int w, int h)
{
    int pitch = WIDTHBYTES(w*sizeof(double)*8);
    doublemap_t *m;

    m = (doublemap_t *)malloc(sizeof(*m)+h*pitch);
    assert(m);
    if (m == NULL) goto __error_return__;
    m->header.width = w;
    m->header.height = h;
    m->header.pitch = pitch;
    m->buffer = (double *)((unsigned char *)m+sizeof(*m));
    memset(m->buffer, 0, h*pitch);
    return m;
__error_return__:;
    return NULL;
}
Пример #16
0
bool Bmp2Jpg(LPBITMAPINFOHEADER head,LPBYTE data, BYTE* &lpJpgBuf, DWORD &nSize)
{
	try{
		int width    = head->biWidth;
		int height   = head->biHeight;
		int nchannels= head->biBitCount / 8;
		IplImage *Img = NULL;
		Img = cvCreateImage(cvSize(width, height), 8, 3);
		int i,j;
		int lw = WIDTHBYTES(head->biBitCount*head->biWidth);
		for(i=0;i<height;++i)
			for(j=0;j<width;++j)
			{
				Img->imageData[(height-1-i)*Img->widthStep+j*3+0] = data[i*lw+nchannels*j+0];
				Img->imageData[(height-1-i)*Img->widthStep+j*3+1] = data[i*lw+nchannels*j+1];
				Img->imageData[(height-1-i)*Img->widthStep+j*3+2] = data[i*lw+nchannels*j+2];
			}
		//取得运行程序的绝对路径 
		CString  strPath(__argv[0]);
		strPath  =  strPath.Left(strPath.ReverseFind('\\')); 
		CString sFile(strPath+"\\TempJpgFile.jpg");
		cvSaveImage(sFile, Img);

		try{
			
			CFile  jpgFile(sFile, CFile::modeRead);
			nSize = jpgFile.GetLength();	
			
			lpJpgBuf = new BYTE[nSize];
			jpgFile.Read(lpJpgBuf, nSize);
			jpgFile.Close();
		}
		catch( CFileException e) {
			CString ErrorInfoStr;
			ErrorInfoStr.Format("文件"+e.m_strFileName+"读入失败!");
			AfxMessageBox(ErrorInfoStr);
		}
		CFile::Remove( sFile );			
		return true;
	}
	catch(...) 
	{
		ASSERT(NULL);
		return false;
	}
}
Пример #17
0
// save Jpeg file
BOOL CJpeg::Save(LPCSTR lpstrFileName, CDib* pDib, BOOL bColor, int nQuality)
{
	if (pDib == NULL)
		pDib = m_pDib;
	if (pDib == NULL)
		return FALSE;

	HDIB hDib = CopyHandle(pDib->GetHandle());
	if (hDib == NULL)
		return FALSE;

	CDib* pDibTmp = new CDib;
	pDibTmp->Attach(hDib);

	if (pDibTmp->GetBitCount() != 24)
		pDibTmp->ConvertFormat(24);

	UINT uWidth  = pDibTmp->GetWidth();
	UINT uHeight = pDibTmp->GetHeight();

	// convert from DIB format (DWORD aligned, vertically flipped, red and blue swapped)
	BYTE* tmp = ClearDwordAlign(pDibTmp->GetBitsPtr(),
									uWidth,
									WIDTHBYTES(uWidth * 24),
									uHeight);
	if (tmp == NULL)
		return FALSE;

	// convert from DIB
	VertFlipBuf(tmp, uWidth*3, uHeight);

	BGRFromRGB(tmp, uWidth, uHeight);

	BOOL bSuccess = WriteJPEGFile(lpstrFileName,
							tmp,
							uWidth, 
							uHeight,
							bColor,
							nQuality);

	delete pDibTmp;
	FreeBuffer(tmp);

	return bSuccess;
}
Пример #18
0
// 计算长轴长度
double SpermParamCalc::GetLength()
{
	long  Width = m_lpDibIHPro->biWidth;
	long  Height= m_lpDibIHPro->biHeight;
	long  ByteWidth = WIDTHBYTES(Width * m_lpDibIHPro->biBitCount); 

    int n = m_HeadEdgePoint.size();

	double  dist, max = 0;
	LPBYTE  lpSrcI = NULL, lpSrcJ = NULL;
	int i, j;  
	int maxI, maxJ;
	maxI = 0;
	maxJ = 0;
	for(i=0; i<n; i++) {	
		for(j=i+1; j<n; j++) {

			lpSrcI = m_lpDibDataPro + m_HeadEdgePoint[i].x*ByteWidth + m_HeadEdgePoint[i].y*3;
			lpSrcJ = m_lpDibDataPro + m_HeadEdgePoint[j].x*ByteWidth + m_HeadEdgePoint[j].y*3;
		
			if( PIEXL(lpSrcI) != PIEXL(lpSrcJ) ) {  
				dist = distance(m_HeadEdgePoint[i], m_HeadEdgePoint[j]);
				if(dist > max) {	
				   max = dist;
				   maxI = i;
				   maxJ = j;
				}
			}			
		}
	}
    if(n == 0)
		return sqrt(max);

	lpSrcI = m_lpDibDataPro + m_HeadEdgePoint[maxI].x*ByteWidth + m_HeadEdgePoint[maxI].y*3;
	if( PIEXL(lpSrcI) == BLUE_PIEXL ){	
		m_ProlateTip[0] = m_HeadEdgePoint[maxI]; // 让头尾相接处点存放于m_ProlateTip[0]
		m_ProlateTip[1] = m_HeadEdgePoint[maxJ]; 
	}
	else{	
		m_ProlateTip[0] = m_HeadEdgePoint[maxJ]; // 让头尾相接处点存放于m_ProlateTip[0]
		m_ProlateTip[1] = m_HeadEdgePoint[maxI]; 
	}
	return  sqrt(max);

}
Пример #19
0
void PutPoints(int nWidth,int nHeight,BYTE *lpBits,BYTE *lpPoints)
{
	int x,y,p,p1;
	int nByteWidth = WIDTHBYTES(nWidth*24); //nWidth*3;
	//if (nByteWidth%4) nByteWidth+=4-(nByteWidth%4);

	for(y=0;y<nHeight;y++)
	{
		for(x=0;x<nWidth;x++)
		{
			p=x*3+y*nByteWidth;
			p1=x+y*nWidth;
			lpBits[p]=lpPoints[p1];
			lpBits[p+1]=lpPoints[p1];
			lpBits[p+2]=lpPoints[p1];
		}
	}
}
Пример #20
0
/* Bestimmen der DIB - Info aus einem CF_DIB Speicherblock */
bool CBildObjekt :: DIBInfo (BITMAPINFOHEADER *lpBI) 
{
	if (m_hDIB) {
	// BitmapInfoHeader kopieren 
		*lpBI = *(BITMAPINFOHEADER *)GlobalLock (m_hDIB);

	// DefaultWerte setzen
		if (lpBI->biSizeImage == 0L)
			lpBI->biSizeImage = lpBI->biHeight * 
				WIDTHBYTES ((ULONG)lpBI->biWidth*lpBI->biBitCount);
		if (lpBI->biClrUsed == 0L)
			lpBI->biClrUsed = DIBNumColors (lpBI);
		GlobalUnlock (m_hDIB);
		return true;
	}

return false;
}
void CImg::CleanUp()
{	
	if(m_lpData != NULL)
	{
		int nWidthBytes = WIDTHBYTES((m_pBMIH->biWidth)*m_pBMIH->biBitCount);
		for(int i=0; i<m_pBMIH->biHeight; i++)
		{
			delete[] m_lpData[i];
		}
		delete[] m_lpData;
	}

	if(m_pBMIH != NULL)
	{
		delete[] m_pBMIH;
		m_pBMIH = NULL;
	}
}
Пример #22
0
BOOL CImage::SaveBMP(LPCTSTR lpszFileName)
{
	///*
    CFile file;
	CFileException fe;
	BITMAPFILEHEADER bmfHdr;
	LPBITMAPINFOHEADER lpBI;
	DWORD dwDIBSize;

	if (!file.Open(lpszFileName, CFile::modeCreate | CFile::modeWrite | CFile::shareDenyWrite, &fe)) return FALSE;

	if (m_hImage == NULL) return FALSE;

	lpBI = (LPBITMAPINFOHEADER)::GlobalLock((HGLOBAL)m_hImage);
	if (lpBI == NULL) return FALSE;

	bmfHdr.bfType = DIB_HEADER_MARKER;  // "BM"
	dwDIBSize = *(LPDWORD)lpBI + ::PaletteSize((LPSTR)lpBI);
	if((lpBI->biCompression==BI_RLE8) || (lpBI->biCompression==BI_RLE4))
		dwDIBSize += lpBI->biSizeImage;
	else 
	{
		DWORD dwBmBitsSize;  // Size of Bitmap Bits only
		dwBmBitsSize = WIDTHBYTES((lpBI->biWidth)*((DWORD)lpBI->biBitCount)) * lpBI->biHeight;
		dwDIBSize += dwBmBitsSize;
		lpBI->biSizeImage = dwBmBitsSize;
	}

	bmfHdr.bfSize = dwDIBSize + sizeof(BITMAPFILEHEADER);
	bmfHdr.bfReserved1 = 0;
	bmfHdr.bfReserved2 = 0;
	bmfHdr.bfOffBits=(DWORD)sizeof(BITMAPFILEHEADER)+lpBI->biSize + PaletteSize((LPSTR)lpBI);
	TRY
	{
		file.Write((LPSTR)&bmfHdr, sizeof(BITMAPFILEHEADER));
		//file.WriteHuge(lpBI, dwDIBSize);
		file.Write(lpBI, dwDIBSize);
	}
	CATCH (CFileException, e)
	{
		::GlobalUnlock((HGLOBAL) m_hImage);
		THROW_LAST();
	}
Пример #23
0
/****************************************************************************
*
*     FUNCTION: SetMonoDIBPixel
*
*     PURPOSE:  Sets/Clears a pixel in a 1bpp DIB by directly poking the bits.
*
*     PARAMS:   LPBYTE pANDBits - pointer to the 1bpp image bits
*               DWORD  dwWidth	- width of the DIB
*               DWORD  dwHeight	- height of the DIB
*               DWORD  x        - x location of pixel to set/clear
*               DWORD  y        - y location of pixel to set/clear
*               BOOL   bWhite	- TRUE to set pixel, FALSE to clear it
*
*     RETURNS:  void
*
* History:
*                July '95 - Created
*
\****************************************************************************/
void SetMonoDIBPixel( LPBYTE pANDBits, DWORD dwWidth, DWORD dwHeight, DWORD x, DWORD y, BOOL bWhite )
{
    DWORD	ByteIndex;
    BYTE    BitNumber;

    // Find the byte on which this scanline begins
    ByteIndex = (dwHeight - y - 1) * WIDTHBYTES(dwWidth);
    // Find the byte containing this pixel
    ByteIndex += (x >> 3);
    // Which bit is it?
    BitNumber = (BYTE)( 7 - (x % 8) );

    if( bWhite )
        // Turn it on
        pANDBits[ByteIndex] |= (1<<BitNumber);
    else
        // Turn it off
        pANDBits[ByteIndex] &= ~(1<<BitNumber);
}
Пример #24
0
bool Dib3ToIplImage1(LPBITMAPINFOHEADER head,LPBYTE data, IplImage* img)
{
	try
	{
		int i,j;
		int channels = 1;
		int lw = WIDTHBYTES(head->biBitCount*head->biWidth);
		for(i=0;i<head->biHeight;++i)
			for(j=0;j<head->biWidth;++j)
					img->imageData[(head->biHeight-1-i)*img->widthStep + j + 0]
						= data[i*lw + j*3 + 0];
		return true;	
	}
	catch (...)
	{
		ASSERT(NULL);
		return false;	
	}
}
Пример #25
0
// 标记椭圆轮廓
void SpermParamCalc::OnMarkEllipse()
{
   long  Width = m_lpDibIHPro->biWidth;
   long  Height= m_lpDibIHPro->biHeight;
   long  ByteWidth = WIDTHBYTES(Width * m_lpDibIHPro->biBitCount); 

   int n = m_HeadEdgePoint.size();
   int i;
   LPBYTE lpSrc;

   for(i=0; i<n; i++)
   {
      lpSrc = m_lpDibDataPro + m_HeadEdgePoint[i].x*ByteWidth + m_HeadEdgePoint[i].y*3;
	  *(lpSrc+ 0) = 0;
	  *(lpSrc+ 1) = 0;
	  *(lpSrc+ 2) = 0;
   }
   
} 
Пример #26
0
void AdjustDIBBrightness(unsigned char* rgbImg, unsigned char* chImg, int rows, int cols,const int v)
{
	int nDelta = WIDTHBYTES(24*cols) - cols*24/8;
	BYTE r, g, b;
	for (int ny=0; ny<rows; ny++)
	{
		for (int nx=0; nx<cols/2; nx++){
			const unsigned int m = ny*cols*3+3*nx;
			b = rgbImg[m];
			g = rgbImg[m+1];
			r = rgbImg[m+2];
			ChangeBrightness(v, &r, &g, &b);
			//ChangeContrast(-v+10, &r, &g, &b);
			rgbImg[m] = b;
			rgbImg[m+1] = g;
			rgbImg[m+2] = r;
		}
	}
}
Пример #27
0
bool CBitmapShow::InitialBitmap(int width,int height)
{
     if((Width==width)&&(Height==height)) return true;
	 Width=width;
	 Height=height;
	 if(m_lpBitmapInfo!=NULL) GlobalFreePtr(m_lpBitmapInfo);
	 int colors=GetNumberColors();
	 if(colors==0) colors=256;
	 m_lpBitmapInfo = (LPBITMAPINFO) GlobalAllocPtr(GHND,sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * colors);
	 m_lpBitmapInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	 m_lpBitmapInfo->bmiHeader.biWidth = Width;
	 m_lpBitmapInfo->bmiHeader.biHeight = Height;
	 m_lpBitmapInfo->bmiHeader.biCompression=GetCompressionKind();
	 m_lpBitmapInfo->bmiHeader.biSizeImage = 0;
	 m_lpBitmapInfo->bmiHeader.biXPelsPerMeter = 0;
	 m_lpBitmapInfo->bmiHeader.biYPelsPerMeter = 0;
	 m_lpBitmapInfo->bmiHeader.biPlanes = 1;
	 m_lpBitmapInfo->bmiHeader.biBitCount =GetBitCount();
	 m_lpBitmapInfo->bmiHeader.biClrUsed = 0;
	 m_lpBitmapInfo->bmiHeader.biClrImportant = 0;
	 ILineBytes=WIDTHBYTES(Width*GetBitCount());
	 m_lpBitmapInfo->bmiHeader.biSizeImage=ILineBytes*Height;
     for(int k=0;k<colors;k++) m_lpBitmapInfo->bmiColors[k].rgbRed=m_lpBitmapInfo->bmiColors[k].rgbGreen=m_lpBitmapInfo->bmiColors[k].rgbBlue=k;
	 if(!CreateDIBPalette())
	 {
         if(m_lpBitmapInfo!=NULL) GlobalFreePtr(m_lpBitmapInfo);
         m_lpBitmapInfo=NULL;
		 return false;
	 }
	 if(lpDIBBits!=NULL) GlobalFreePtr(lpDIBBits);
     lpDIBBits=NULL;
     lpDIBBits=(unsigned char*)GlobalAllocPtr(GHND,ILineBytes*Height);
	 if(lpDIBBits==NULL)
	 {
         if(m_lpBitmapInfo!=NULL) GlobalFreePtr(m_lpBitmapInfo);
         m_lpBitmapInfo=NULL;
         if(Palette!=NULL) delete Palette;
		 Palette=NULL;
		 return false;
	 }
	 return true;
}
Пример #28
0
	bool CBmp::load(const char* p_file)
	{
		FILE* fp = NULL;
		fp = fopen(p_file, "rb");
		if (fp == NULL)
			return false;
		head _head;
		info _info;
		fread(&_head, 1, sizeof(head), fp);
		fread(&_info, 1, sizeof(info), fp);
		if (_head.id != 19778 || _info.compress != 0 || _info.bit_per_pixel != 24)
			return false;
		m_w = _info.pixel_width;
		m_h = _info.pixel_height;
		u32 l_width = WIDTHBYTES(m_w * _info.bit_per_pixel);
		u32 color_data_size = m_h * l_width;
		u8* p_color_data = (u8*)malloc(color_data_size);
		memset(p_color_data, 0, color_data_size);
		fread(p_color_data, 1, color_data_size, fp);

		rgb* p_rgb = NULL;
		p_rgb = (rgb*)malloc(m_w * m_h * sizeof(rgb));
		memset(p_rgb, 0, m_w * m_h * sizeof(rgb));

		u32 idx = 0;
		for (u32 y = 0; y < m_h; y++)
		{
			for (u32 x = 0; x < m_w; x++)
			{
				u32 k = y * l_width + x * 3;
				p_rgb[idx].r = p_color_data[k + 2];
				p_rgb[idx].g = p_color_data[k + 1];
				p_rgb[idx].b = p_color_data[k];
				idx++;
			}
		}

		m_p_rgb = (u8*)p_rgb;
		free(p_color_data);
		fclose(fp);
		return true;
	}
Пример #29
0
// 计算头部面积
double SpermParamCalc::GetHeadArea()
{ 
	long  Width = m_lpDibIHPro->biWidth;
	long  Height= m_lpDibIHPro->biHeight;
	long  ByteWidth = WIDTHBYTES(Width * m_lpDibIHPro->biBitCount); 

	int area = 0;
	LPBYTE  lpSrc;
	int i, j;
    for(i=0; i<Height; i++)
	{
		for(j=0; j<Width; j++)
		{
			lpSrc = m_lpDibDataPro+ i*ByteWidth + j*3;
            if( PIEXL(lpSrc) == BLUE_PIEXL ) // 蓝色
			 area++;
		}    
	}

    return area;
}
Пример #30
0
bool DibToIplImage(LPBITMAPINFOHEADER head,LPBYTE data,IplImage* img)
{
	try
	{
		int i,j,k;
		int channels=head->biBitCount/8;
		for(i=0;i<head->biHeight;++i)
			for(j=0;j<head->biWidth;++j)
				for(k=0;k<channels;++k)
				{
					img->imageData[(head->biHeight-1-i)*img->widthStep+j*channels+k]
						= data[i*WIDTHBYTES(head->biBitCount*head->biWidth)+channels*j+k];
				}
		return true;	
	}
	catch (...)
	{
		ASSERT(NULL);
		return false;	
	}
}