extractpixeldataview.cpp

DICOM专用的显示源代码,国外的一位高手写的 我贡献出来给大家学习学习

/* 
 * Permission is given by the author to freely redistribute and include
 * this code in any program.
 *
 * Copyright: (c) 2004, John Fitzgerald <[e-mail]>
 *
 * COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
 * OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
 * THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
 * OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
 * CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
 * THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
 * SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
 * PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
 * THIS DISCLAIMER.
 *
 * Use at your own risk!
 * ==========================================================
 */


// ExtractPixelDataView.cpp : implementation of the CExtractPixelDataView class
//

#include "stdafx.h"
#include "ExtractPixelData.h"
#include "ExtractPixelDataDoc.h"
#include "ExtractPixelDataView.h"
#include "DcmCompositeIOD.h"
//#include "..\dicomapi\DcmCompositeIOD.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CExtractPixelDataView

IMPLEMENT_DYNCREATE(CExtractPixelDataView, CScrollView)

BEGIN_MESSAGE_MAP(CExtractPixelDataView, CScrollView)
	//{{AFX_MSG_MAP(CExtractPixelDataView)
	ON_WM_ERASEBKGND()
	ON_COMMAND(ID_NEXT_DOCUMENT, OnNextDocument)
	ON_COMMAND(ID_PREV_DOCUMENT, OnPrevDocument)
	ON_UPDATE_COMMAND_UI(ID_PREV_DOCUMENT, OnUpdatePrevDocument)
	ON_UPDATE_COMMAND_UI(ID_NEXT_DOCUMENT, OnUpdateNextDocument)
	//}}AFX_MSG_MAP
	// Standard printing commands
	ON_COMMAND(ID_FILE_PRINT, CScrollView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_DIRECT, CScrollView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, CScrollView::OnFilePrintPreview)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CExtractPixelDataView construction/destruction

CExtractPixelDataView::CExtractPixelDataView()
{
	// TODO: add construction code here

}

CExtractPixelDataView::~CExtractPixelDataView()
{
}

BOOL CExtractPixelDataView::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs

	return CScrollView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CExtractPixelDataView drawing

void CExtractPixelDataView::OnDraw(CDC* pDC)
{

	CExtractPixelDataDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	{
		pDC->SelectClipRgn(NULL );
	}
	// jpeg images are OLE objects
	if ( pDoc->m_jpegPixelData.GetSize() != 0 )
	{
		ASSERT ( !(pDoc->m_ImageIndex >= pDoc->m_jpegPixelData.GetSize()) );
		if (pDoc->m_ImageIndex >= pDoc->m_jpegPixelData.GetSize() ) return;
	
		if ( pDoc->m_CurrentIndex != pDoc->m_ImageIndex )
		{
			pDoc->m_CurrentIndex = pDoc->m_ImageIndex;
			CByteArray* frame = (CByteArray*)pDoc->m_jpegPixelData[pDoc->m_ImageIndex];
			ASSERT ( frame != NULL );
			if ( frame == NULL ) return;
			TRY
			{
				CString pathname;
				::GetTempPath(255, 	pathname.GetBufferSetLength(255) );
				pathname.ReleaseBuffer();
				CFile f;
				CString& pFileName = pathname + "ole.jpg";
				{
					CFile f( pFileName, CFile::modeWrite | CFile::modeCreate );
					f.WriteHuge( frame->GetData(), frame->GetSize() );
				}
				LPPICTURE Picture = NULL;
				USES_CONVERSION;
				HRESULT hr = OleLoadPicturePath( const_cast <LPOLESTR>(T2COLE ( pFileName) ),
								  NULL, 0, 0, IID_IPicture, reinterpret_cast<LPVOID *>(&Picture) );
				if (SUCCEEDED(hr) && Picture != NULL)
				{
					if ( pDoc->m_Picture != NULL )
					{
						pDoc->m_Picture->Release();
					}
					pDoc->m_Picture = Picture;
				}
			}
			CATCH( CFileException, e )
			{
			   #ifdef _DEBUG
				  afxDump << "File could not be opened " << e->m_cause << "\n";
			   #endif
				
			}
			END_CATCH
		}
		
		LPPICTURE Picture = pDoc->m_Picture;

		if ( Picture == NULL ) return;

		int width =  pDoc->m_Width;
		int height =  pDoc->m_Height;
		SetScrollSizes(MM_TEXT, CSize( width, height ) );


		HPALETTE hPal;
		Picture->get_hPal(reinterpret_cast<OLE_HANDLE *>(&hPal));

		CPalette *pPalTemp = NULL;
		if (hPal != NULL)
		{
			pPalTemp = pDC->SelectPalette(CPalette::FromHandle(hPal),
				FALSE);
			pDC->RealizePalette();
		}
		CSize metric;
		Picture->get_Width(&metric.cx);
		Picture->get_Height(&metric.cy);
		CRect rect;
		GetClientRect(&rect);
		Picture->Render(pDC->GetSafeHdc(), 0, 0, width ,height , 0, metric.cy, metric.cx, -metric.cy, &rect);
		if (pPalTemp != NULL) pDC->SelectPalette (pPalTemp, FALSE);
 	}
	else if (  pDoc->m_CookedPixelData.GetSize() != 0 )
	{	
// Convert pixel data to dib then present to gdi
		if (pDoc->m_ImageIndex >= pDoc->m_CookedPixelData.GetSize() ) return;

		CObArray& PixelData = pDoc->m_CookedPixelData;

		int width =  pDoc->m_Width;
		int height =  pDoc->m_Height;

		SetScrollSizes(MM_TEXT, CSize( width, height ) );

		unsigned BitsPerPixel = pDoc->m_BitsPerPixel;


		CByteArray* frame = ( CByteArray*)PixelData[pDoc->m_ImageIndex];
		ASSERT( frame != NULL );
		if ( frame == NULL ) return;
		if ( frame->GetSize() == 0 ) return;
		
		BITMAPINFO*  pbmInfo =  (BITMAPINFO*)new BYTE [sizeof(BITMAPINFO) + sizeof( RGBQUAD )* 256] ;

		if ( pbmInfo != NULL )
		{
			memset(&pbmInfo->bmiHeader, 0, sizeof(BITMAPINFOHEADER));
			pbmInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
			pbmInfo->bmiHeader.biWidth = width;
			pbmInfo->bmiHeader.biHeight = -height;
			pbmInfo->bmiHeader.biPlanes =  1;
			pbmInfo->bmiHeader.biBitCount  =  BitsPerPixel;
			pbmInfo->bmiHeader.biCompression = BI_RGB;

			for( int k = 0; k < 256; k++ )
			{
				pbmInfo->bmiColors[k].rgbBlue = k;
				pbmInfo->bmiColors[k].rgbGreen = k;
				pbmInfo->bmiColors[k].rgbRed = k;
				pbmInfo->bmiColors[k].rgbReserved = 0;
			}
			VOID *ppvBits;
			HBITMAP hBitmap = CreateDIBSection( pDC->GetSafeHdc(),
				pbmInfo, DIB_RGB_COLORS, (void**)&ppvBits , 0  ,  0);
			if ( hBitmap != NULL )
			{
				memcpy ( ppvBits, frame->GetData(), frame->GetSize() );
				CBitmap* pBitmap =  CBitmap::FromHandle( hBitmap );
				BITMAP bm;
				CDC MemDC;
				pBitmap->GetObject( sizeof ( bm ), (LPVOID)&bm );
				MemDC.CreateCompatibleDC( pDC );
				CBitmap* temp = ( CBitmap*)MemDC.SelectObject( pBitmap );
				pDC->BitBlt( 0, 0, bm.bmWidth, bm.bmHeight, &MemDC, 0, 0, SRCCOPY );
				MemDC.SelectObject( temp ); 
				DeleteObject ( hBitmap );
			}
			delete pbmInfo;
		}
	}
	else
	{
		ASSERT ( false );
	}
}

BOOL CExtractPixelDataView::OnEraseBkgnd(CDC* pDC) 
{
	CExtractPixelDataDoc* pDoc = GetDocument();
	pDC->ExcludeClipRect(CRect (0 , 0, pDoc->m_Width  , pDoc->m_Height ) );  
	CRect rect;
	GetClientRect( rect );
	pDC->FillSolidRect(rect, RGB( 192,192,192 ) );
	return true;
}
/////////////////////////////////////////////////////////////////////////////
// CExtractPixelDataView printing

BOOL CExtractPixelDataView::OnPreparePrinting(CPrintInfo* pInfo)
{
	return DoPreparePrinting(pInfo);
}

void CExtractPixelDataView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add extra initialization before printing
}

void CExtractPixelDataView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add cleanup after printing
}

/////////////////////////////////////////////////////////////////////////////
// CExtractPixelDataView diagnostics

#ifdef _DEBUG
void CExtractPixelDataView::AssertValid() const
{
	CScrollView::AssertValid();
}

void CExtractPixelDataView::Dump(CDumpContext& dc) const
{
	CScrollView::Dump(dc);
}

CExtractPixelDataDoc* CExtractPixelDataView::GetDocument() // non-debug version is inline
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CExtractPixelDataDoc)));
	return (CExtractPixelDataDoc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CExtractPixelDataView message handlers

void CExtractPixelDataView::OnInitialUpdate() 
{

	SetScrollSizes(MM_TEXT, CSize( 0,0 ) );
	CScrollView::OnInitialUpdate();

	GetDocument()->SetTitle( GetDocument()->GetPathName() );

	CDcmRegistry registry;
	CDcmImagePixelModule& ipm = GetDocument()->m_ImagePixel;
	CDcmMetaFileInformation& mfi = GetDocument()->m_MetaFile; 
	CDcmMultiFrameModule&  mfm = GetDocument()->m_MultiFrame;
	CDcmVioLutModule& vlm = GetDocument()->m_VioLut;
	CDcmModalityLUTModule& mlm  = GetDocument()->m_ModalityLut;

	CString& syntax = mfi.TransferSyntaxUID();

	int TransferSyntax = registry.UidEnum( syntax );

	if ( TransferSyntax == CDcmRegistry::DcmUnDefinedUid )
	{
		 TransferSyntax = GetDocument()->m_IodSyntax;
	}