Project Semi Photoshop/Spike Solution

~cpp 
class CImage
{
protected:
	HDIB m_hImage;		//image handle
	HDIB m_hUndoImage;	         //undo image handle
	CSize m_Size;		//image size

public:
	BOOL InitDIB(BOOL bCreatePalette = TRUE);
	void SetHandle(HANDLE hHandle);
	BOOL CreateDIBPalette();

	virtual ~CImage() { Free(); }
	void Free();

	int GetBitCount();
	HDIB GetHandle()		{return m_hImage;}
	BOOL IsDataNull()		{return (m_hImage == NULL);}
	CSize GetSize()		{return m_Size;}	
	int GetHeight()		{return m_Size.cy;}
	int GetWidth()		{return m_Size.cx;}
	int GetRealWidth()		{return WIDTHBYTES((GetWidth()*GetBitCount()));}
	HDIB GetUndoHandle()	{return m_hUndoImage;}
	CPalette *GetPalette()	{return m_pPal;}

	BOOL Draw(HDC hDC, LPRECT sourceRect, LPRECT destRect);

	BOOL Save(LPCTSTR lpszFileName);
	BOOL Load(LPCTSTR lpszFileName);

protected:
	BOOL LoadBMP(LPCTSTR lpszFileName);
	BOOL SaveBMP(LPCTSTR lpszFileName);
};

/******************************************************
				DIB��� ��������� ������ 함���
******************************************************/
LPSTR WINAPI FindDIBBits(LPSTR lpbi)
{
	return (lpbi + *(LPDWORD)lpbi + ::PaletteSize(lpbi));
}

DWORD WINAPI DIBWidth(LPSTR lpDIB)
{
	LPBITMAPINFOHEADER lpbmi;  // pointer to a Win 3.0-style DIB
	LPBITMAPCOREHEADER lpbmc;  // pointer to an other-style DIB

	/* point to the header (whether Win 3.0 and old) */

	lpbmi = (LPBITMAPINFOHEADER)lpDIB;
	lpbmc = (LPBITMAPCOREHEADER)lpDIB;

	/* return the DIB width if it is a Win 3.0 DIB */
	if (IS_WIN30_DIB(lpDIB))
		return lpbmi->biWidth;
	else  /* it is an other-style DIB, so return its width */
		return (DWORD)lpbmc->bcWidth;
}

DWORD WINAPI DIBHeight(LPSTR lpDIB)
{
	LPBITMAPINFOHEADER lpbmi;  // pointer to a Win 3.0-style DIB
	LPBITMAPCOREHEADER lpbmc;  // pointer to an other-style DIB

	/* point to the header (whether old or Win 3.0 */

	lpbmi = (LPBITMAPINFOHEADER)lpDIB;
	lpbmc = (LPBITMAPCOREHEADER)lpDIB;

	/* return the DIB height if it is a Win 3.0 DIB */
	if (IS_WIN30_DIB(lpDIB))
		return lpbmi->biHeight;
	else  /* it is an other-style DIB, so return its height */
		return (DWORD)lpbmc->bcHeight;
}

WORD WINAPI PaletteSize(LPSTR lpbi)
{
   /* calculate the size required by the palette */
   if (IS_WIN30_DIB (lpbi))
	  return (WORD)(::DIBNumColors(lpbi) * sizeof(RGBQUAD));
   else
	  return (WORD)(::DIBNumColors(lpbi) * sizeof(RGBTRIPLE));
}

WORD WINAPI DIBNumColors(LPSTR lpbi)
{
	WORD wBitCount;  // DIB bit count

	/*  If this is a Windows-style DIB, the number of colors in the
	 *  color table can be less than the number of bits per pixel
	 *  allows for (i.e. lpbi->biClrUsed can be set to some value).
	 *  If this is the case, return the appropriate value.
	 */

	if (IS_WIN30_DIB(lpbi))
	{
		DWORD dwClrUsed;

		dwClrUsed = ((LPBITMAPINFOHEADER)lpbi)->biClrUsed;
		if (dwClrUsed != 0)
			return (WORD)dwClrUsed;
	}

	/*  Calculate the number of colors in the color table based on
	 *  the number of bits per pixel for the DIB.
	 */
	if (IS_WIN30_DIB(lpbi))
		wBitCount = ((LPBITMAPINFOHEADER)lpbi)->biBitCount;
	else
		wBitCount = ((LPBITMAPCOREHEADER)lpbi)->bcBitCount;

	/* return number of colors based on bits per pixel */
	switch (wBitCount)
	{
		case 1:
			return 2;

		case 4:
			return 16;

		case 8:
			return 256;

		default:
			return 0;
	}
}

/******************************************************
				클������������ ���한 ������ 함���
******************************************************/
HGLOBAL WINAPI CopyHandle (HGLOBAL h)
{
	if (h == NULL)
		return NULL;

	DWORD dwLen = ::GlobalSize((HGLOBAL) h);
	HGLOBAL hCopy = ::GlobalAlloc(GHND, dwLen);

	if (hCopy != NULL)
	{
		void* lpCopy = ::GlobalLock((HGLOBAL) hCopy);
		void* lp     = ::GlobalLock((HGLOBAL) h);
		memcpy(lpCopy, lp, dwLen);
		::GlobalUnlock(hCopy);
		::GlobalUnlock(h);
	}

	return hCopy;
}

~cpp 
BOOL CImage::Load(LPCTSTR lpszFileName)
{
	CString filetype;
	filetype = lpszFileName;
	filetype.MakeUpper();

	if(filetype.Find(".BMP") > -1) return LoadBMP(lpszFileName);
	else if(filetype.Find(".TIF") > -1) return LoadTIF(lpszFileName);
	else if(filetype.Find(".GIF") > -1) return LoadGIF(lpszFileName);
	else if(filetype.Find(".JPG") > -1) return LoadJPG(lpszFileName);
	else return FALSE;
}

~cpp 
BOOL CImage::LoadBMP(LPCTSTR lpszFileName)
{
	CFile file;
	CFileException fe;
	LPSTR pDIB;
	DWORD dwBitsSize;
	BITMAPFILEHEADER bmfHeader;

	// ������ ��������� 파��� ������
	if(!file.Open(lpszFileName, CFile::modeRead|CFile::shareDenyWrite, &fe))
		return FALSE;

	// 파������ ��������� ���함
	dwBitsSize = file.GetLength();

	// 파��� 헤��� ������
	if(file.Read((LPSTR)&bmfHeader, sizeof(bmfHeader))!=sizeof(bmfHeader))
		return FALSE;

	// BMP 파��������� ����������� "BM" ��������� ��������� 확���
	if (bmfHeader.bfType != DIB_HEADER_MARKER)
		return FALSE;

	// ��������� 할���
	if((m_hImage = (HDIB)::GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, dwBitsSize)) == NULL) return FALSE;

	// ��������� ������
	pDIB = (LPSTR) ::GlobalLock((HGLOBAL) m_hImage);

	// 파��� ������
	if (file.ReadHuge(pDIB, dwBitsSize - sizeof(BITMAPFILEHEADER)) != dwBitsSize - sizeof(BITMAPFILEHEADER) ) 
	{
		::GlobalUnlock((HGLOBAL) m_hImage);
		::GlobalFree((HGLOBAL) m_hImage);
		return FALSE;
	}

	// ��������� ��������
	::GlobalUnlock((HGLOBAL) m_hImage);

	// DIB ������화
	InitDIB();

	return TRUE;
}

~cpp 
BOOL CImage::Save(LPCTSTR lpszFileName)
{
	CString filetype;
	filetype = lpszFileName;
	filetype.MakeUpper();

	if(filetype.Find(".BMP") > -1) return SaveBMP(lpszFileName);
	else if(filetype.Find(".TIF") > -1) return SaveTIF(lpszFileName);
	else if(filetype.Find(".GIF") > -1) return SaveGIF(lpszFileName);
	else if(filetype.Find(".JPG") > -1) return SaveJPG(lpszFileName);
	else return FALSE;
}

~cpp 
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);
	}
	CATCH (CFileException, e)
	{
		::GlobalUnlock((HGLOBAL) m_hImage);
		THROW_LAST();
	}
	END_CATCH

	// ��������� ��������
	::GlobalUnlock((HGLOBAL) m_hImage);
	return TRUE;
}

~cpp 
HDIB CMyImage::MosaicProcess()
{
	LPSTR pDIB;
	LPSTR pPixels;
	int i,j;
	long lw;		// ������ ��������� Width������������.
	int avrcolor;	// ���환 ����� Color������������.

	// ��������� ������
	pDIB = (LPSTR) ::GlobalLock((HGLOBAL) m_hImage);

	//����������������� ������ ��������� ���합������.
	pPixels = DataBits(pDIB); 

	// ��������� ��������� 4��� ��������� ��������������� ������ ��� ���합������.
	lw = m_Size.cx + (m_Size.cx%4>0?(4-m_Size.cx%4):0);

	// ��������� 픽��������� ������한 ��������� 평���화 합������.
	for (i=0;i<m_Size.cy;i+=2)
	{
		for (j=0;j<m_Size.cx;j+=2)
		{
			avrcolor = 0;
			avrcolor += (int)((BYTE *)pPixels)[i*lw+j];
			avrcolor += (int)((BYTE *)pPixels)[i*lw+(j+1)];
			avrcolor += (int)((BYTE *)pPixels)[(i+1)*lw+j];
			avrcolor += (int)((BYTE *)pPixels)[(i+1)*lw+(j+1)];
			avrcolor/=4;
			((BYTE *)pPixels)[i*lw+j] = (char)avrcolor;
			((BYTE *)pPixels)[i*lw+(j+1)] = (char)avrcolor;
			((BYTE *)pPixels)[(i+1)*lw+j] = (char)avrcolor;
			((BYTE *)pPixels)[(i+1)*lw+(j+1)] = (char)avrcolor;
		}
	}
	// ��������� ���������
	::GlobalUnlock((HGLOBAL) m_hImage);

	return (HDIB)pDIB;
}