visualeffect.cpp

image processing for transmission micrscopy. Using ray casting and visual effect for dectecttion and

// VisualEffect.cpp : implementation file
//

#include "stdafx.h"
#include "CVisualEffect.h"
#include "VisualEffect.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif


/////////////////////////////////////////////////////////////////////////////
// CVisualEffect

CVisualEffect::CVisualEffect()
{
	
}

CVisualEffect::~CVisualEffect()
{
	
}


BEGIN_MESSAGE_MAP(CVisualEffect, CStatic)
	//{{AFX_MSG_MAP(CVisualEffect)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CVisualEffect message handlers
void CVisualEffect::SetImage(CString FileName)
{
	m_Display.SetParent(this);
	
	CImg<float> tmp = FileName;
	m_Original = tmp;
}

void CVisualEffect::DrawImage()
{
	m_Display.DrawImage(m_Original);

	_DrawThread_ dt;
	dt.window=m_Display.window;
	dt.Original=&m_Original;

	AfxBeginThread(DrawThread, &dt, THREAD_PRIORITY_BELOW_NORMAL);
}

void CImgDisplayEx::SetSize(const UINT iWidth, UINT iHeight)
{
	width=iWidth;
	height=iHeight;
}

void CImgDisplayEx::SetParent(CWnd* pParent)
{
	window=pParent->m_hWnd;
}

void CImgDisplayEx::DrawImage(const CImg<float>& pimg)
{
	cimg_test(pimg);
    CImg<float> tmp;
    const CImg<float>& img = (pimg.depth==1)?pimg:(tmp=pimg.get_3dplanes(pimg.width/2,pimg.height/2,pimg.depth/2));
    width = img.width; height = img.height;
    new_lowlevel();
    display(img);
}

void CImgDisplayEx::new_lowlevel()
{
	unsigned long ThreadID;
    DEVMODE mode;
    HDC dc;
    uint imode=0,ibest=0,currbpp=0;
    
	if (event_type&4) 
	{
		while (EnumDisplaySettings(NULL,imode++,&mode))
			if (mode.dmPelsWidth==width && mode.dmPelsHeight==height && mode.dmBitsPerPel>currbpp && mode.dmBitsPerPel>=24) 
			{
				currbpp = mode.dmBitsPerPel; 
				ibest=imode-1; 
			}

		cimg::warn(!currbpp,"CImgDisplay::new_lowlevel() : Could not initialize fullscreen mode %dx%d\n",width,height);
		
		if (currbpp) 
		{
			EnumDisplaySettings(NULL,ibest,&mode);
			
			dc = GetDC(NULL);
			
			resx = GetDeviceCaps(dc,HORZRES);
			resy = GetDeviceCaps(dc,VERTRES);
			resbpp = GetDeviceCaps(dc,BITSPIXEL);
			
			ChangeDisplaySettings(&mode,0);
		}
		else	
			resx = resy = resbpp = 0;
    }
    else 
		resx = resy = resbpp = 0;


    if (event_type&3) 
	{
		mutex = CreateMutex(NULL,FALSE,NULL);
		created = CreateEvent(NULL,FALSE,FALSE,NULL);
		wait_disp = CreateEvent(NULL,FALSE,FALSE,NULL);
		thread = CreateThread(NULL,0,thread_lowlevel,this,0,&ThreadID);
		WaitForSingleObject(created,INFINITE);
    } 
	else 
		thread_lowlevel(this);
}

DWORD WINAPI CImgDisplayEx::thread_lowlevel(void* arg)
{
    CImgDisplayEx* disp  = (CImgDisplayEx*) arg;
    
    MSG msg;
    
    disp->bmi.bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
    disp->bmi.bmiHeader.biWidth=disp->width;
    disp->bmi.bmiHeader.biHeight=-(int)disp->height;
    disp->bmi.bmiHeader.biPlanes=1;
    disp->bmi.bmiHeader.biBitCount=32;
    disp->bmi.bmiHeader.biCompression=BI_RGB;
    disp->bmi.bmiHeader.biSizeImage=0;
    disp->bmi.bmiHeader.biXPelsPerMeter=1;
    disp->bmi.bmiHeader.biYPelsPerMeter=1;
    disp->bmi.bmiHeader.biClrUsed=0;
    disp->bmi.bmiHeader.biClrImportant=0;
    disp->data = new uint[disp->width*disp->height];
    
	disp->hdc = GetDC(disp->window);
    
	if (disp->event_type&3) 
	{
      SetWindowLong(disp->window,GWL_USERDATA,(LONG) disp);
      SetWindowLong(disp->window,GWL_WNDPROC,(LONG) proc_lowlevel);
      SetEvent(disp->created);
      
	  while (GetMessage( &msg, NULL, 0, 0 ) ) 
	  { 
		  DispatchMessage(&msg); 
		  SetEvent(disp->wait_disp); 
	  }
    }
    
	return 0;
}


LRESULT APIENTRY CImgDisplayEx::proc_lowlevel(HWND window,UINT msg,WPARAM wParam,LPARAM lParam) 
{
    CImgDisplayEx* disp = (CImgDisplayEx*) GetWindowLong(window,GWL_USERDATA);
    const uint event_type = disp->event_type&3;
    MSG st_msg;
    switch (msg) 
	{
		case WM_CLOSE: 
			disp->closed=true; 
			ReleaseMutex(disp->mutex); 
			ShowWindow(disp->window,SW_HIDE); 
			return 0;

		case WM_SIZE:
			if (LOWORD(lParam)>disp->width || HIWORD(lParam)>disp->height) 
			{
				WaitForSingleObject(disp->mutex,INFINITE);
				SetWindowPos(window,HWND_TOP,0,0,disp->width,disp->height+24,SWP_NOMOVE);
				ReleaseMutex(disp->mutex);
			}
			break;

		case WM_PAINT:
			WaitForSingleObject(disp->mutex,INFINITE);
			SetDIBitsToDevice(disp->hdc,0,0,disp->width,disp->height,0,0,0,disp->height,disp->data,&(disp->bmi),DIB_RGB_COLORS);
			ReleaseMutex(disp->mutex);
			break;
    }

    if (event_type>=2) 
		switch(msg) 
		{
			case WM_KEYDOWN:     
				while (PeekMessage(&st_msg,window,WM_KEYDOWN,WM_KEYDOWN,PM_REMOVE)); 
				disp->key=(int)wParam; 
				break;

			//case WM_MOUSELEAVE: fprintf(stderr,"exit windows\n"); break;
			case WM_MOUSEMOVE:   
				while (PeekMessage(&st_msg,window,WM_MOUSEMOVE,WM_MOUSEMOVE,PM_REMOVE));
				disp->mousex = LOWORD(lParam);
				disp->mousey = HIWORD(lParam);
				if (disp->mousex<0) 
					disp->mousex = 0;
      
				if (disp->mousey<0) 
					disp->mousey = 0;
				
				if (disp->mousex>=(int)disp->width)  
					disp->mousex = disp->width-1;
      
				if (disp->mousey>=(int)disp->height) 
					disp->mousey = disp->height-1;
				
				break;

			case WM_LBUTTONDOWN: 
				while (PeekMessage(&st_msg,window,WM_LBUTTONDOWN,WM_LBUTTONDOWN,PM_REMOVE)); 
				disp->button |= 1;  
				break;
    
			case WM_RBUTTONDOWN: 
				while (PeekMessage(&st_msg,window,WM_RBUTTONDOWN,WM_RBUTTONDOWN,PM_REMOVE)); 
				disp->button |= 2;  
				break;
    
			case WM_MBUTTONDOWN: 
				while (PeekMessage(&st_msg,window,WM_MBUTTONDOWN,WM_MBUTTONDOWN,PM_REMOVE)); 
				disp->button |= 4;  
				break;
		}
    
	if (event_type>=3) 
		switch(msg) 
		{
			case WM_KEYUP:       
				while (PeekMessage(&st_msg,window,WM_KEYUP,WM_KEYUP,PM_REMOVE));         
				disp->key=0; 
				break;
    
			case WM_LBUTTONUP:   
				while (PeekMessage(&st_msg,window,WM_LBUTTONUP,WM_LBUTTONUP,PM_REMOVE)); 
				disp->button &= ~1; 
				break;
    
			case WM_RBUTTONUP:   
				while (PeekMessage(&st_msg,window,WM_RBUTTONUP,WM_RBUTTONUP,PM_REMOVE)); 
				disp->button &= ~2; 
				break;
    
			case WM_MBUTTONUP:   
				while (PeekMessage(&st_msg,window,WM_MBUTTONUP,WM_MBUTTONUP,PM_REMOVE)); 
				disp->button &= ~4; 
				break;
		}
    
	return DefWindowProc(window,msg,wParam,lParam);
}


UINT CVisualEffect::DrawThread(LPVOID pParam)
{
	Sleep(150);
	
	_DrawThread_* pdt=(_DrawThread_*) pParam;

	CImgDisplayEx* disp = (CImgDisplayEx*) GetWindowLong(pdt->window,GWL_USERDATA);
	CImg<float>* Original=(CImg<float>*) pdt->Original;
	CImg<uchar> visu(*Original);
	
	for (double sigma=1.57075;;sigma+=0.05)
	{
		visu = Original->get_blur((float)std::fabs(30*std::cos(sigma))).normalize(0,255);
		disp->display(visu).wait_sync(20);
	}	
}