Working with CBitmap and BITMAP

// ECAEDDoc.h : interface of the CECAEDDoc class
//
/////////////////////////////////////////////////////////////////////////////
#if !defined(AFX_ECAEDDOC_H__64E67B6C_E0ED_4F6D_8A70_2387DE188471__INCLUDED_)
#define AFX_ECAEDDOC_H__64E67B6C_E0ED_4F6D_8A70_2387DE188471__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class CECAEDDoc : public CDocument
{
protected: // create from serialization only
	CECAEDDoc();
	DECLARE_DYNCREATE(CECAEDDoc)
// Attributes
public:
	CBitmap m_bmpIn;
	CBitmap m_bmpOut;
// Operations
public:
// Overrides
	// ClassWizard generated virtual function overrides
	//{{AFX_VIRTUAL(CECAEDDoc)
	public:
	virtual BOOL OnNewDocument();
	virtual void Serialize(CArchive& ar);
	virtual BOOL OnOpenDocument(LPCTSTR lpszPathName);
	//}}AFX_VIRTUAL
// Implementation
public:
	virtual ~CECAEDDoc();
#ifdef _DEBUG
	virtual void AssertValid() const;
	virtual void Dump(CDumpContext& dc) const;
#endif
protected:
// Generated message map functions
protected:
	//{{AFX_MSG(CECAEDDoc)
		// NOTE - the ClassWizard will add and remove member functions here.
		//    DO NOT EDIT what you see in these blocks of generated code !
	//}}AFX_MSG
	DECLARE_MESSAGE_MAP()
};
/////////////////////////////////////////////////////////////////////////////
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_ECAEDDOC_H__64E67B6C_E0ED_4F6D_8A70_2387DE188471__INCLUDED_)

// ECAEDDoc.cpp : implementation of the CECAEDDoc class
//
#include "stdafx.h"
#include "ECAED.h"
#include "ECAEDDoc.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CECAEDDoc
IMPLEMENT_DYNCREATE(CECAEDDoc, CDocument)
BEGIN_MESSAGE_MAP(CECAEDDoc, CDocument)
	//{{AFX_MSG_MAP(CECAEDDoc)
		// NOTE - the ClassWizard will add and remove mapping macros here.
		//    DO NOT EDIT what you see in these blocks of generated code!
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CECAEDDoc construction/destruction
CECAEDDoc::CECAEDDoc()
{
	// TODO: add one-time construction code here
}
CECAEDDoc::~CECAEDDoc()
{
}
BOOL CECAEDDoc::OnNewDocument()
{
	if (!CDocument::OnNewDocument())
		return FALSE;
	// TODO: add reinitialization code here
	// (SDI documents will reuse this document)
	return TRUE;
}

/////////////////////////////////////////////////////////////////////////////
// CECAEDDoc serialization
void CECAEDDoc::Serialize(CArchive& ar)
{
	if (ar.IsStoring())
	{
		// TODO: add storing code here
	}
	else
	{
		// TODO: add loading code here
	}
}
/////////////////////////////////////////////////////////////////////////////
// CECAEDDoc diagnostics
#ifdef _DEBUG
void CECAEDDoc::AssertValid() const
{
	CDocument::AssertValid();
}
void CECAEDDoc::Dump(CDumpContext& dc) const
{
	CDocument::Dump(dc);
}
#endif //_DEBUG
/////////////////////////////////////////////////////////////////////////////
// CECAEDDoc commands
BOOL CECAEDDoc::OnOpenDocument(LPCTSTR lpszPathName) 
{
	if (!CDocument::OnOpenDocument(lpszPathName))
		return FALSE;
	
	// TODO: Add your specialized creation code here
	// Load the selected bitmap file
	HBITMAP hBitmap = (HBITMAP)::LoadImage(NULL, lpszPathName, IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION | LR_LOADFROMFILE);
	
	// Do we have a valid handle for the loaded image?
	if (hBitmap)
	{
		// Delete the current bitmap
		m_bmpIn.DeleteObject();
		
		// Attach the currently loaded bitmap to the bitmap object
		m_bmpIn.Attach(hBitmap);
	}
	DIBSECTION ds;
	
	::GetObject(hBitmap, sizeof(DIBSECTION), &ds);
	BITMAPINFO bmi;
	LPBYTE pBits = (LPBYTE)ds.dsBm.bmBits;
	LPBYTE pBitsOut;
	HBITMAP hBitmapOut;
	// Initialize header to 0s.
	ZeroMemory(&bmi, sizeof(bmi));
	// Fill out the fields you care about.
	bmi.bmiHeader = ds.dsBmih;
	hBitmapOut = CreateDIBSection(GetDC(NULL), &bmi, DIB_RGB_COLORS, (LPVOID*)&pBitsOut, NULL, 0);
	if (!hBitmap || !pBitsOut)
		return NULL;
	
	// Do we have a valid handle for the created image?
	if (hBitmapOut)
	{
		// Delete the current bitmap
		m_bmpOut.DeleteObject();
		
		// Attach the currently loaded bitmap to the bitmap object
		m_bmpOut.Attach(hBitmapOut);
	}
	DIBSECTION dsOut;
	
	::GetObject(hBitmapOut, sizeof(DIBSECTION), &dsOut);
	
	::SetDIBits(GetDC(NULL), hBitmapOut, 0, dsOut.dsBm.bmHeight, pBits, &bmi, DIB_RGB_COLORS);
	
	int Mask[3][3] = {{-2, -1, -2},
					  {-1, 12, -1},
					  {-2, -1, -2}};
	int sumR;
	int sumG;
	int sumB;
	
	for (int y = 0; y < dsOut.dsBm.bmHeight; y ++)
		for (int x = 0; x < dsOut.dsBm.bmWidth; x ++)
		{
			sumR = 0;
			sumG = 0;
			sumB = 0;
			for (int i = 0; i < 3; i ++)
			{
				if ((y + i - 1) < 0 || (y + i - 1) > dsOut.dsBm.bmHeight)
						continue;
				for (int j = 0; j < 3; j ++)
				{
					if ((x + j - 1) < 0 || (x + j - 1) > dsOut.dsBm.bmWidth)
						continue;
					
					sumB += pBits[(y + i - 1) * ds.dsBm.bmWidthBytes + (x * ds.dsBm.bmBitsPixel / 8) + j - 1] * Mask[i][j] / 2;
					sumG += pBits[(y + i - 1) * ds.dsBm.bmWidthBytes + (x * ds.dsBm.bmBitsPixel / 8) + j - 1 + 1] * Mask[i][j] / 2;
					sumR += pBits[(y + i - 1) * ds.dsBm.bmWidthBytes + (x * ds.dsBm.bmBitsPixel / 8) + j - 1 + 2] * Mask[i][j] / 2;
				}
			}
			if (sumR < 0)
				sumR = 0;
			if (sumR > 255)
				sumR = 255;
			if (sumG < 0)
				sumG = 0;
			if (sumG > 255)
				sumG = 255;
			if (sumB < 0)
				sumB = 0;
			if (sumB > 255)
				sumB = 255;
			pBitsOut[y * dsOut.dsBm.bmWidthBytes + (x * dsOut.dsBm.bmBitsPixel / 8)] = sumB;
			pBitsOut[y * dsOut.dsBm.bmWidthBytes + (x * dsOut.dsBm.bmBitsPixel / 8) + 1] = sumG;
			pBitsOut[y * dsOut.dsBm.bmWidthBytes + (x * dsOut.dsBm.bmBitsPixel / 8) + 2] = sumR;
		}
		
		return TRUE;
}