pixel.cpp

来自「网络泡泡被.net管理」· C++ 代码 · 共 1,232 行 · 第 1/3 页

	template <class t_reader>
	void read_encoded( fstream& buffer, PIX32* dest, int width, int delta,
	                   t_reader reader )
	{
		int        run_size;
		PIX32 pixel;

		while (width > 0)
		{
			run_size = get<BYTE>(buffer);
			if (run_size & 0x80)
			{
				pixel = reader( buffer );
				run_size = (run_size & 0x7f) + 1;
				assert( run_size <= width );
				while (run_size--)
				{
					*dest = pixel;
					width--;
					dest += delta;
				}
			}
			else
			{
				run_size++;
				assert( run_size <= width );
				while (run_size--)
				{
					*dest = reader( buffer );
					width--;
					dest += delta;
				}
			}
		}
	}

}; // unnnamed namespace

inline CPixelMap32::CPixelMap32()
{
	m_pPix		= NULL;
	m_dwWidth		= 0;
	m_dwHeight	= 0;
	psd_cache		= NULL;
	psd_cache_file	= "";
	m_name			= KEY("");
	m_point			= GPOINT(0,0);
}

CPixelMap32::~CPixelMap32()
{ 
	Clear(); 
	t_photoshop_image*	p_image	= (t_photoshop_image*)psd_cache;
	SAFE_DELETE(p_image);
}


BOOL CPixelMap32::Create( DWORD width, DWORD height )
{
	Clear();
	m_pPix	= (PIX32*)new char[sizeof(PIX32)*width*height];
	if(m_pPix)
	{
		m_dwWidth		= width;
		m_dwHeight	= height;
//		memset(m_pPix, 0, sizeof(PIX32)*width*height);
		return true;
	}
	m_name			= KEY("");
	m_point			= GPOINT(0,0);
	return false;
}

VOID CPixelMap32::Clear()
{
	SAFE_DELETE_ARRAY(m_pPix);
	m_dwWidth = 0;
	m_dwHeight = 0;
}

BOOL CPixelMap32::LoadFromTgaFile(const char* szFile)
{
	fstream      file;
	file.open( szFile, ios::in | ios::binary );
	if ( !file.good() )
		return false;
	LoadFromTgaFileBuffer( file );
	file.close();

	char	filename[PATH_SIZE];

	CGsFunc::Path_GetPathFile(filename, szFile);

	m_name	= KEY(filename);
	return true;
}

VOID CPixelMap32::LoadFromTgaFileBuffer(fstream& buffer)
{
	t_targa_header            header;
	std::vector<PIX24>		targa_palette;

	buffer.read((char*)&header, sizeof( header ));
	//read( buffer, &header, sizeof( header ));
	// skip the description
	buffer.seekg( header.description_length, ios::cur );

	//m_dwWidth			= header.width;
	//m_dwHeight		= header.height;
	//m_PixelBits		= header.bits_per_pixel;


	// read the palette, if any.
	if (header.has_palette)
	{
		//return;
		assert( header.bits_per_palette_entry == 24 );
		targa_palette.resize( header.palette_size + header.first_palette_index );
		//read( buffer, targa_palette.begin() + header.first_palette_index, 
		//	  header.palette_size * sizeof( PIX24 ) );
		read( buffer, targa_palette.begin() + header.first_palette_index, 
			  header.palette_size * sizeof( PIX24 ) );
	
	}

	POINT            start;
	POINT            point;
	POINT            delta;

	Create(header.width ,header.height);
	//int a = sizeof( PIX32 )*header.width * header.height;
	//p_pixmap->pPix 	= (PIX32*)new char[a];//new PIX32[ header.width * header.height ];

	if (header.flags & 0x10 )
	{
		start.x = header.width - 1;
		delta.x = -1;
	}
	else
	{
		start.x = 0;
		delta.x = 1;
	}
	if (header.flags & 0x20 )
	{
		start.y = 0;
		delta.y = 1;
	}
	else
	{
		start.y = header.height - 1;
		delta.y = -1;
	}

	int         row;
	PIX32* dest;

	row = header.height;
	point.y = start.y;


	//ifs.read((char*)p_pixmap->pPix, 2400*1200*4);
	while (row--)
	{
		dest = GetData() + point.y * header.width + start.x;

		switch (header.format)
		{
			
			case k_targa_paletted:
				read_raw( buffer, dest, header.width, delta.x, 
					      t_get_paletted_pixel( targa_palette.begin() ) );
				break;
			
			case k_targa_rgb:
				if (header.bits_per_pixel == 32)
				{
					//buffer.read((char*)dest, sizeof( PIX32 )*header.width);

					read( buffer, dest, sizeof( PIX32 )*header.width);
					//dest += delta.x*header.width;

					//read_raw( buffer, dest, header.width, delta.x, t_get_rgb_alpha_pixel() );
				}
				else
				{
					read_raw( buffer, dest, header.width, delta.x, t_get_rgb_pixel() );
				}
				break;

			case k_targa_grayscale:
				read_raw( buffer, dest, header.width, delta.x, t_get_grayscale_pixel() );
				break;

			
			case k_targa_paletted_encoded:
				read_encoded( buffer, dest, header.width, delta.x, 
					          t_get_paletted_pixel( targa_palette.begin() ) );
				break;
			

			case k_targa_rgb_encoded:
				if (header.bits_per_pixel == 32)
					read_encoded( buffer, dest, header.width, delta.x, t_get_rgb_alpha_pixel() );
				else
					read_encoded( buffer, dest, header.width, delta.x, t_get_rgb_pixel() );
				break;

			case k_targa_grayscale_encoded:
				read_encoded( buffer, dest, header.width, delta.x, t_get_grayscale_pixel() );
				break;
		}
		point.y += delta.y;
	}	
}

GPOINT CPixelMap32::LoadFromPsdFile(const char* szFile, const char* szLayer)
{
	t_photoshop_image*	p_image	= (t_photoshop_image*)psd_cache;
	if(psd_cache_file!=szFile)
	{
		SAFE_DELETE(p_image);
		p_image	= new t_photoshop_image;
		std::filebuf fbuf;
		if(0==fbuf.open(szFile, std::ios::in | std::ios::binary))
			return GPOINT(0,0);

		p_image->read(fbuf);
		psd_cache_file	= szFile;
		psd_cache	= p_image;
		fbuf.close();
	}
// 	int aaa	= image.get_layer_count();
//	int a= image.get_width();
//	int b= image.get_height();
 	t_photoshop_layer_ptr layer	= p_image->get_layer(szLayer);

	if(!Create(layer->get_width(), layer->get_height()))
		return GPOINT(0,0);

	GRECT rc	= layer->get_rect();
	for(int y=0; y<layer->get_height(); y++)
	{
		for(int x=0; x<layer->get_width(); x++)
		{
//			if(layer->get_pixel(x,y).alpha!=0)
//				PIX32 pix=layer->get_pixel(x,y);
			this->m_pPix[x + y*layer->get_width()]	= layer->get_pixel(x+rc.left,y+rc.top);
		}
	}

	char	filename[PATH_SIZE];
	CGsFunc::Path_GetPathFile(filename, szFile);
	CGsFunc::TextFormatString(m_name, "%s\\%s", filename, szLayer);

	m_name	= KEY(filename);

	m_point	= GPOINT(rc.left, rc.top);

	return GPOINT(-rc.left, -rc.top);
}

GPOINT CPixelMap32::LoadFromPsdFile(const char* szFile, int idLayer)
{
	t_photoshop_image*	p_image	= (t_photoshop_image*)psd_cache;
	if(psd_cache_file!=szFile)
	{
		SAFE_DELETE(p_image);
		p_image	= new t_photoshop_image;
		std::filebuf fbuf;
		if(0==fbuf.open(szFile, std::ios::in | std::ios::binary))
			return GPOINT(0,0);

		p_image->read(fbuf);
		psd_cache_file	= szFile;
		psd_cache	= p_image;
		fbuf.close();
	}

 	t_photoshop_layer_ptr layer	= p_image->get_layer(idLayer);

	if(!Create(layer->get_width(), layer->get_height()))
		return GPOINT(0,0);

	GRECT rc	= layer->get_rect();
	for(int y=0; y<layer->get_height(); y++)
	{
		for(int x=0; x<layer->get_width(); x++)
		{
			this->m_pPix[x + y*layer->get_width()]	= layer->get_pixel(x+rc.left,y+rc.top);
		}
	}

	char	filename[PATH_SIZE];
	CGsFunc::Path_GetPathFile(filename, szFile);
	CGsFunc::TextFormatString(m_name, "%s\\%s", filename, layer->get_name().c_str());

	m_name	= KEY(filename);

	m_point	= GPOINT(rc.left, rc.top);

	return GPOINT(-rc.left, -rc.top);
}




CDibMap::CDibMap()
{
	lpDib	= NULL;
}

VOID CDibMap::Clear()
{
	SAFE_DELETE_ARRAY(lpDib);
}

BOOL CDibMap::CreateFormBitmap( GSFBUF& fbuf )
{
	DWORD fsize = fbuf.file_size;
	BITMAPFILEHEADER bmfHeader;
	if(0==fsize)
	{
//		DWORD pos	= fbuf.pfstream->tellg();
//		fbuf.pfstream->seekg(0,ios::end);
//		fsize	= fbuf.pfstream->tellg() - pos;
//		fbuf.pfstream->seekg(pos,ios::beg);
		DWORD pos	= ftell(fbuf.p_fstream);
		fseek(fbuf.p_fstream, 0, SEEK_END);
		fsize	= ftell(fbuf.p_fstream);
		fseek(fbuf.p_fstream, 0, SEEK_SET);
	}
	if(fsize<=sizeof(bmfHeader))
		return false;
	Clear();
	lpDib	= new char[fsize];
	if(NULL==lpDib)
		return false;

//	fbuf.pfstream->read((char*)&bmfHeader, sizeof(bmfHeader));
//
//	fbuf.pfstream->read(lpDib, fsize - sizeof(bmfHeader));

	fread(&bmfHeader, sizeof(bmfHeader), 1, fbuf.p_fstream);

	fread(lpDib, 1, fsize - sizeof(bmfHeader), fbuf.p_fstream);

	return true;
}

BOOL CDibMap::SaveToBitmap(char const* szfile)
{


	return true;
}

BOOL CDibMap::Paint(HDC hDC, GRECT const& rcSrc,GRECT const& rcDes)
{
	LPSTR    lpDIBBits;           // Pointer to DIB bits
	BOOL     bSuccess=FALSE;      // Success/fail flag
	HPALETTE hPal=NULL;           // Our DIB's palette
	HPALETTE hOldPal=NULL;        // Previous palette

	/* Check for valid DIB handle */
	if (lpDib == NULL)
		return FALSE;

	/* Lock down the DIB, and get a pointer to the beginning of the bit
	 *  buffer
	 */
	lpDIBBits = FindDIBBits();

	// Get the DIB's palette, then select it into DC
	hPal	= CreateDIBPalette();
	if (hPal != NULL)
	{
		// Select as background since we have
		// already realized in forground if needed
		hOldPal = SelectPalette(hDC, hPal, TRUE);
	}

	/* Make sure to use the stretching mode best for color pictures */
	::SetStretchBltMode(hDC, COLORONCOLOR);

	/* Determine whether to call StretchDIBits() or SetDIBitsToDevice() */
	if ((rcDes.width()  == rcSrc.width()) &&
	   (rcDes.height() == rcSrc.height()))
		bSuccess = ::SetDIBitsToDevice(hDC,                    // hDC
								   rcDes.left,             // DestX
								   rcDes.top,              // DestY
								   rcDes.width(),        // nDestWidth
								   rcDes.height(),       // nDestHeight
								   rcSrc.left,            // SrcX
								   (int)DIBHeight() -
									  rcSrc.top -
									  rcSrc.height(),   // SrcY
								   0,                          // nStartScan
								   (WORD)DIBHeight(),  // nNumScans
								   lpDIBBits,                  // lpBits
								   (LPBITMAPINFO)lpDib,     // lpBitsInfo
								   DIB_RGB_COLORS);            // wUsage
	else
		bSuccess = ::StretchDIBits(hDC,                          // hDC
								rcDes.left,                 // DestX
								rcDes.top,                  // DestY
								rcDes.width(),            // nDestWidth
								rcDes.height(),           // nDestHeight
								rcSrc.left,                // SrcX
								rcSrc.top,                 // SrcY
								rcSrc.width(),           // wSrcWidth