开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 3D图形编程 > 查看源码
StereoPlusDlg.cpp
资源名称：estereo2.zip　[点击查看]
上传用户：fengshi120
上传日期：2014-07-17
资源大小：6155k
文件大小：30k
源码类别：

3D图形编程

开发平台：

C/C++

StereoPlusDlg.cpp：源码内容
  1. // StereoPlusDlg.cpp : implementation file
  2. //
  4. #include "stdafx.h"
  5. #include <gdiplus.h>
  6. #include "StereoPlus.h"
  7. #include "GeneralPurpose.h"
  9. #include "StereoPlusDlg.h"
  10. #include ".stereoplusdlg.h"
  11. #include "stereomatching.h"
  12. #include "DirectXDialog.h"
  13. #include "ThumbnailFileDialog.h"
  15. #ifdef _DEBUG
  16. #define new DEBUG_NEW
  17. #undef THIS_FILE
  18. static char THIS_FILE[] = __FILE__;
  19. #endif
  21. // CStereoPlusDlg dialog
  22. #define MIN_HOROPTER -500
  23. #define MAX_HOROPTER 500
  25. #define MIN_DISPARITY_RANGE 8
  26. #define MAX_DISPARITY_RANGE 128
  28. #define MIN_CORRELATION_WINDOW 5
  29. #define MAX_CORRELATION_WINDOW 49
  31. #define MIN_SAD_THRESHOLD 0
  32. #define MAX_SAD_THRESHOLD 99
  35. #define MIN_DISPARITY_IMAGE_SCALE 0
  36. #define MAX_DISPARITY_IMAGE_SCALE 4
  39. #define DELETENULL(object) if (object) {delete object;object = NULL;}
  41. CStereoPlusDlg* pMainDialog = NULL;
  43. CStereoPlusDlg::CStereoPlusDlg(CWnd* pParent /*=NULL*/)
  44. : CDialog(CStereoPlusDlg::IDD, pParent)
  45. , m_iDisparityRange(0)
  46. , m_iHoropter(0)
  47. , m_iCorrelationWindow(0)
  48. , m_iSADThreshold(0)
  49. , m_iDisparityImageScale(0)
  50. , m_bPropagateStereo(FALSE)
  51.   , m_SADControls(this,IDC_STATIC_CONTROLS)
  52. , m_fBaseLine(0)
  53. , m_fFocalLength(0)
  54. , m_bSwapLeftRight(FALSE)
  55. , m_iImageResampleWidth(0)
  56. {
  57. m_bClosing = false;
  58. m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
  59. m_pLeftImageBitmap = NULL;
  60. m_pRightImageBitmap = NULL;
  61. m_pDisparityBitmap = NULL;
  62. m_bSizeChanged = true;
  63. m_bNewFilesLoaded = false;
  64. m_pLeftBitmapData = NULL;
  65. m_pRightBitmapData = NULL;
  66. m_bImagesAreSwapped = FALSE;
  67. m_iImageXTranslation = 0;
  68. m_iImageYTranslation = 0;
  70. m_fFocalLength = 260.0f / 0.01;
  71. m_fBaseLine = 100.0f;
  74. m_pStereoContext = NULL;
  75. m_pPts3d = NULL;
  76. m_bPropagateStereo  = false;
  78. m_bGreyScaleDataLoaded = false;
  79. m_fExtentX = 1.0f;
  80. m_fExtentZ = 1.0f;
  83. m_iHoropter = theApp.GetProfileInt("SAD Params","Horopter",0);
  84. m_iDisparityRange = theApp.GetProfileInt("SAD Params","Disparity Range",32);
  85. m_iCorrelationWindow = theApp.GetProfileInt("SAD Params","Correlation Window Size",7);
  86. m_iSADThreshold = theApp.GetProfileInt("SAD Params","SAD Threshold",2);
  87. m_iDisparityImageScale = theApp.GetProfileInt("SAD Params","Disparity Image Scale",1);
  88. m_bPropagateStereo = theApp.GetProfileInt("SAD Params","Propagate Stereo",0);
  89. m_fFocalLength = (float)theApp.GetProfileDouble("Recon Params","Focal Length",150.0);
  90. m_fBaseLine = (float)theApp.GetProfileDouble("Recon Params","Base Line",0.05);
  91. m_iImageResampleWidth = theApp.GetProfileInt("Image Options","Resample Size",320);
  92. m_bResample = theApp.GetProfileInt("Image Options","Resample ON",1);
  93. m_iImageXTranslation = theApp.GetProfileInt("Image Options","xAxis Translate",0);
  94. m_iImageYTranslation = theApp.GetProfileInt("Image Options","yAxis Translate",0);
  97. InitStereoContext();
  99. pMainDialog = this;
  100. }
  102. CStereoPlusDlg::~CStereoPlusDlg()
  103. {
  104. theApp.WriteProfileInt("SAD Params","Disparity Range",m_iDisparityRange);
  105. theApp.WriteProfileInt("SAD Params","Horopter",m_iHoropter);
  106. theApp.WriteProfileInt("SAD Params","Correlation Window Size",m_iCorrelationWindow);
  107. theApp.WriteProfileInt("SAD Params","SAD Threshold",m_iSADThreshold);
  108. theApp.WriteProfileInt("SAD Params","Disparity Image Scale",m_iDisparityImageScale);
  109. theApp.WriteProfileInt("SAD Params","Propagate Stereo",m_bPropagateStereo);
  110. theApp.WriteProfileDouble("Recon Params","Focal Length",(double)m_fFocalLength);
  111. theApp.WriteProfileDouble("Recon Params","Base Line",(double)m_fBaseLine);
  112. theApp.WriteProfileInt("Image Options","Resample Size",m_iImageResampleWidth);
  113. theApp.WriteProfileInt("Image Options","Resample ON",m_bResample);
  114. theApp.WriteProfileInt("Image Options","xAxis Translate",m_iImageXTranslation);
  115. theApp.WriteProfileInt("Image Options","yAxis Translate",m_iImageYTranslation);
  116. if(m_pLeftImageBitmap)
  117. {
  118. delete m_pLeftImageBitmap;
  119. m_pLeftImageBitmap = NULL;
  120. }
  121. if(m_pRightImageBitmap)
  122. {
  123. delete m_pRightImageBitmap;
  124. m_pRightImageBitmap = NULL;
  125. }
  126. if(m_pDisparityBitmap)
  127. {
  128. delete m_pDisparityBitmap;
  129. m_pDisparityBitmap = NULL;
  130. }
  132. if(m_pLeftBitmapData) 
  133. delete [] m_pLeftBitmapData;
  135. if(m_pRightBitmapData) 
  136. delete [] m_pRightBitmapData;
  139. if(m_pStereoContext)
  140. delete m_pStereoContext;
  142. if(m_pPts3d)
  143. delete m_pPts3d;
  144. }
  147. void CStereoPlusDlg::DoDataExchange(CDataExchange* pDX)
  148. {
  149. CDialog::DoDataExchange(pDX);
  150. DDX_Text(pDX, IDC_EDIT_DISPARITYRANGE, m_iDisparityRange);
  151. DDV_MinMaxInt(pDX, m_iDisparityRange, MIN_DISPARITY_RANGE, MAX_DISPARITY_RANGE);
  152. DDX_Text(pDX, IDC_EDIT_HOROPTER, m_iHoropter);
  153. DDV_MinMaxInt(pDX, m_iHoropter, MIN_HOROPTER, MAX_HOROPTER);
  154. DDX_Text(pDX, IDC_EDIT_CORRWINSIZE, m_iCorrelationWindow);
  155. DDV_MinMaxInt(pDX, m_iCorrelationWindow, MIN_CORRELATION_WINDOW, MAX_CORRELATION_WINDOW);
  156. DDX_Text(pDX, IDC_EDIT_SADTHRESH, m_iSADThreshold);
  157. DDV_MinMaxInt(pDX, m_iSADThreshold, MIN_SAD_THRESHOLD, MAX_SAD_THRESHOLD);
  158. DDX_Text(pDX, IDC_EDIT_DISPARITYSCALE, m_iDisparityImageScale);
  159. DDV_MinMaxInt(pDX, m_iDisparityImageScale, MIN_DISPARITY_IMAGE_SCALE, MAX_DISPARITY_IMAGE_SCALE);
  160. DDX_Check(pDX, IDC_CHECK_STEREOPROPAG, m_bPropagateStereo);
  161. DDX_Text(pDX, IDC_EDIT_BASE_LINE, m_fBaseLine);
  162. DDV_MinMaxFloat(pDX, m_fBaseLine, 0.00001f, 1000.0f);
  163. DDX_Text(pDX, IDC_EDIT_FOCAL_LENGTH, m_fFocalLength);
  164. DDV_MinMaxFloat(pDX, m_fFocalLength, 1.0f, 100000.0f);
  165. DDX_Check(pDX, IDC_CHECK_SWAP, m_bSwapLeftRight);
  166. DDX_Control(pDX, IDC_CHECK_SWAP, m_ctrlCheckSwapLeftRight);
  167. DDX_Control(pDX, IDC_CHECK_RESAMPLE, m_ctrlResampleImages);
  168. DDX_Text(pDX, IDC_EDIT_RESAMPLE_WIDTH, m_iImageResampleWidth);
  169. DDV_MinMaxInt(pDX, m_iImageResampleWidth, 64, 1280);
  170. DDX_Control(pDX, IDC_EDIT_RESAMPLE_WIDTH, m_ctrlEditResampleWidth);
  171. DDX_Text(pDX, IDC_EDIT_XTRANSLATE, m_iImageXTranslation);
  172. DDX_Text(pDX, IDC_EDIT_YTRANSLATE, m_iImageYTranslation);
  173. }
  175. BEGIN_MESSAGE_MAP(CStereoPlusDlg, CDialog)
  176. ON_WM_PAINT()
  177. ON_WM_QUERYDRAGICON()
  178. //}}AFX_MSG_MAP
  179. ON_BN_CLICKED(IDC_BUTTON_LOAD_LEFT, OnBnClickedButtonLoadLeft)
  180. ON_WM_DESTROY()
  181. ON_WM_SIZE()
  182. ON_BN_CLICKED(IDC_BUTTON_LOAD_RIGHT, OnBnClickedButtonLoadRight)
  183. ON_BN_CLICKED(IDC_BUTTON_LOAD_PAIR, OnBnClickedButtonLoadPair)
  184. ON_BN_CLICKED(IDC_BUTTON_DO_STEREO, OnBnClickedButtonDoStereo)
  185. ON_NOTIFY(UDN_DELTAPOS, IDC_SPIN_DISPARITYRANGE, OnDeltaposSpinDisparityrange)
  186. ON_NOTIFY(UDN_DELTAPOS, IDC_SPIN_HOROPTER, OnDeltaposSpinHoropter)
  187. ON_NOTIFY(UDN_DELTAPOS, IDC_SPIN_CORRWINSIZE, OnDeltaposSpinCorrwinsize)
  188. ON_NOTIFY(UDN_DELTAPOS, IDC_SPIN_SADTHRESH, OnDeltaposSpinSadthresh)
  189. ON_NOTIFY(UDN_DELTAPOS, IDC_SPIN_DISPARITYSCALE, OnDeltaposSpinDisparityscale)
  190. ON_BN_CLICKED(IDC_CHECK_STEREOPROPAG, OnBnClickedCheckStereoPropagation)
  191. ON_WM_CLOSE()
  192. ON_BN_CLICKED(IDC_BUTTON_DO_RECONSTRUCTION_DIRECTX, OnBnClickedButtonDoReconstructionDirectx)
  193. ON_BN_CLICKED(IDC_CHECK_SWAP, OnBnClickedCheckSwap)
  194. ON_BN_CLICKED(IDC_CHECK_RESAMPLE, OnBnClickedCheckResample)
  195. ON_NOTIFY(UDN_DELTAPOS, IDC_SPIN_XTRANSLATE, OnDeltaposSpinXtranslate)
  196. ON_NOTIFY(UDN_DELTAPOS, IDC_SPIN_YTRANSLATE, OnDeltaposSpinYtranslate)
  197. ON_BN_CLICKED(IDC_BUTTON_SAVEDISPARITY, OnBnClickedButtonSavedisparity)
  198. END_MESSAGE_MAP()
  201. // CStereoPlusDlg message handlers
  203. BOOL CStereoPlusDlg::OnInitDialog()
  204. {
  205. CDialog::OnInitDialog();
  207. m_strLeftImagePath = theApp.GetProfileString("Images","Left Image","C:\");
  208. m_strRightImagePath = theApp.GetProfileString("Images","Right Image","C:\");
  209. m_strImagePairPath = theApp.GetProfileString("Images","Image Pair","C:\");
  211. // Set the icon for this dialog.  The framework does this automatically
  212. //  when the application's main window is not a dialog
  213. SetIcon(m_hIcon, TRUE); // Set big icon
  214. SetIcon(m_hIcon, FALSE); // Set small icon
  216. m_ctrlEditResampleWidth.EnableWindow(m_bResample);
  217. if(m_bResample)
  218. m_ctrlResampleImages.SetCheck(BST_CHECKED);
  219. //this is so the controls maintain there position relative to IDC_STATIC_CONTROLS
  220. //when that window is moved by the user resizing the app window
  222. m_SADControls.AddControl(IDC_STATIC_SAD_FRAME);
  223. m_SADControls.AddControl(IDC_BUTTON_DO_STEREO);
  224. m_SADControls.AddControl(IDC_BUTTON_SAVEDISPARITY);
  225. m_SADControls.AddControl(IDC_STATIC_TEXT1);
  226. m_SADControls.AddControl(IDC_STATIC_TEXT2);
  227. m_SADControls.AddControl(IDC_STATIC_TEXT3);
  228. m_SADControls.AddControl(IDC_STATIC_TEXT4);
  230. m_SADControls.AddControl(IDC_SPIN_DISPARITYRANGE);
  231. m_SADControls.AddControl(IDC_SPIN_HOROPTER);
  232. m_SADControls.AddControl(IDC_SPIN_CORRWINSIZE);
  233. m_SADControls.AddControl(IDC_SPIN_SADTHRESH);
  234. m_SADControls.AddControl(IDC_SPIN_DISPARITYSCALE);
  235. m_SADControls.AddControl(IDC_CHECK_STEREOPROPAG);
  237. m_SADControls.AddControl(IDC_EDIT_DISPARITYRANGE);
  238. m_SADControls.AddControl(IDC_EDIT_HOROPTER);
  239. m_SADControls.AddControl(IDC_EDIT_CORRWINSIZE);
  240. m_SADControls.AddControl(IDC_EDIT_SADTHRESH);
  241. m_SADControls.AddControl(IDC_EDIT_DISPARITYSCALE);
  242. m_SADControls.AddControl(IDC_STATIC_PROPAGATION_FRAME);
  243. m_SADControls.AddControl(IDC_BUTTON_DO_RECONSTRUCTION_DIRECTX);
  244. m_SADControls.AddControl(IDC_STATIC_SCALE_FRAME);
  247. m_SADControls.AddControl(IDC_EDIT_BASE_LINE);
  248. m_SADControls.AddControl(IDC_EDIT_FOCAL_LENGTH);
  249. m_SADControls.AddControl(IDC_STATIC_FOCAL_LENGTH);
  250. m_SADControls.AddControl(IDC_STATIC_BASE_LINE);
  251. m_SADControls.AddControl(IDC_STATIC_RECON_FRAME);
  252. m_SADControls.AddControl(IDC_CHECK_SWAP);
  253. m_SADControls.AddControl(IDC_STATIC_IMAGE_FRAME);
  254. m_SADControls.AddControl(IDC_EDIT_RESAMPLE_WIDTH);
  255. m_SADControls.AddControl(IDC_STATIC_WIDTH);
  256. m_SADControls.AddControl(IDC_CHECK_RESAMPLE);
  257. m_SADControls.AddControl(IDC_STATIC_XTRANSLATE);
  258. m_SADControls.AddControl(IDC_EDIT_XTRANSLATE);
  259. m_SADControls.AddControl(IDC_SPIN_XTRANSLATE);
  260. m_SADControls.AddControl(IDC_STATIC_YTRANSLATE);
  261. m_SADControls.AddControl(IDC_EDIT_YTRANSLATE);
  262. m_SADControls.AddControl(IDC_SPIN_YTRANSLATE);
  265. return TRUE;  // return TRUE  unless you set the focus to a control
  266. }
  272. // If you add a minimize button to your dialog, you will need the code below
  273. //  to draw the icon.  For MFC applications using the document/view model,
  274. //  this is automatically done for you by the framework.
  276. void CStereoPlusDlg::OnPaint() 
  277. {
  278. if (IsIconic())
  279. {
  280. CPaintDC dc(this); // device context for painting
  282. SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);
  284. // Center icon in client rectangle
  285. int cxIcon = GetSystemMetrics(SM_CXICON);
  286. int cyIcon = GetSystemMetrics(SM_CYICON);
  287. CRect rect;
  288. GetClientRect(&rect);
  289. int x = (rect.Width() - cxIcon + 1) / 2;
  290. int y = (rect.Height() - cyIcon + 1) / 2;
  292. // Draw the icon
  293. dc.DrawIcon(x, y, m_hIcon);
  294. }
  295. else
  296. {
  297. CDialog::OnPaint();
  298. if(m_bSizeChanged)
  299. ArrangeControls();
  301. DrawBitmap(IDC_STATIC_LEFT,m_pLeftImageBitmap);
  302. DrawBitmap(IDC_STATIC_RIGHT,m_pRightImageBitmap);
  303. DrawBitmap(IDC_STATIC_DISPARITY,m_pDisparityBitmap);
  305. }
  306. }
  308. // The system calls this function to obtain the cursor to display while the user drags
  309. //  the minimized window.
  310. HCURSOR CStereoPlusDlg::OnQueryDragIcon()
  311. {
  312. return static_cast<HCURSOR>(m_hIcon);
  313. }
  315. void CStereoPlusDlg::OnBnClickedButtonLoadLeft()
  316. {
  317. if(SelectImageFile(m_strLeftImagePath))
  318. {
  319. m_bGreyScaleDataLoaded = false;
  321. if(m_pLeftImageBitmap)
  322. {
  323. delete m_pLeftImageBitmap;
  324. m_pLeftImageBitmap = NULL;
  325. }
  327. WCHAR wString[MAX_PATH];
  328. MultiByteToWideChar (CP_ACP, 0,m_strLeftImagePath,-1,wString,MAX_PATH);
  329. // load bitmap
  330. m_pLeftImageBitmap = new Bitmap(wString);
  332. if(m_bResample)
  333. ResampleBitmap(m_pLeftImageBitmap,m_iImageResampleWidth);
  336. DrawBitmap(IDC_STATIC_LEFT,m_pLeftImageBitmap);
  338. m_bNewFilesLoaded = true;
  340. }
  341. }
  343. void CStereoPlusDlg::OnBnClickedButtonLoadRight()
  344. {
  345. if(SelectImageFile(m_strRightImagePath))
  346. {
  347. m_bGreyScaleDataLoaded = false;
  349. if(m_pRightImageBitmap)
  350. {
  351. delete m_pRightImageBitmap;
  352. m_pRightImageBitmap = NULL;
  353. }
  355. WCHAR wString[MAX_PATH];
  356. MultiByteToWideChar (CP_ACP, 0,m_strRightImagePath,-1,wString,MAX_PATH);
  358. m_pRightImageBitmap = new Bitmap(wString);
  360. if(m_bResample)
  361. ResampleBitmap(m_pRightImageBitmap,m_iImageResampleWidth);
  363. DrawBitmap(IDC_STATIC_RIGHT,m_pRightImageBitmap);
  365. m_bNewFilesLoaded = true;
  367. }
  368. }
  370. void CStereoPlusDlg::ResampleBitmap(Bitmap *&pBitmap,UINT iNewWidth)
  371. {
  372. UINT w = pBitmap->GetWidth();
  373. UINT h = pBitmap->GetHeight();
  375. float fAspect = (float)h/(float)w;
  376. UINT wSmall = iNewWidth;
  377. UINT hSmall = (int)(iNewWidth*fAspect);
  379. Bitmap *pNewBitmap = new Bitmap(wSmall,hSmall);
  381. Graphics* pGraphics = new Graphics(pNewBitmap);
  382. Rect rcDst(0,0,wSmall,hSmall);
  385. pGraphics->DrawImage(pBitmap,rcDst,0,0,w,h, UnitPixel,NULL,NULL,NULL);
  387. delete pGraphics;
  389. delete pBitmap;
  390. pBitmap = pNewBitmap;
  391. }
  393. void CStereoPlusDlg::OnBnClickedButtonLoadPair()
  394. {
  395. if(SelectImageFile(m_strImagePairPath))
  396. {
  397. m_bGreyScaleDataLoaded = false;
  399. if(m_pRightImageBitmap)
  400. {
  401. delete m_pRightImageBitmap;
  402. m_pRightImageBitmap = NULL;
  403. }
  405. if(m_pLeftImageBitmap)
  406. {
  407. delete m_pLeftImageBitmap;
  408. m_pLeftImageBitmap = NULL;
  409. }
  412. WCHAR wString[MAX_PATH];
  413. MultiByteToWideChar (CP_ACP, 0,m_strImagePairPath,-1,wString,MAX_PATH);
  415. Bitmap* pPairBitmap = new Bitmap(wString);
  416. if(pPairBitmap->GetLastStatus() == Ok)
  417. {
  418. int w = pPairBitmap->GetWidth();
  419. int h = pPairBitmap->GetHeight();
  420. m_pLeftImageBitmap = pPairBitmap->Clone(0,0,w/2,h,PixelFormat24bppRGB);
  421. if(m_bResample)
  422. ResampleBitmap(m_pLeftImageBitmap,m_iImageResampleWidth);
  425. m_pRightImageBitmap = pPairBitmap->Clone(w/2,0,w/2,h,PixelFormat24bppRGB);
  426. if(m_bResample)
  427. ResampleBitmap(m_pRightImageBitmap,m_iImageResampleWidth);
  430. m_bNewFilesLoaded = true;
  431. }
  432. delete pPairBitmap;
  435. }
  436. }
  438. BYTE* CStereoPlusDlg::GetGrayScaleData(Bitmap* pBitmap)
  439. {
  440. //Gdiplus sucks at manipulating greyscale images so it's simpler to just extract the luminance directly
  441. UINT uWidth = pBitmap->GetWidth();
  442. UINT uHeight = pBitmap->GetHeight();
  444. BitmapData *pBitmapData = new BitmapData;
  445. UINT nPixels = pBitmap->GetWidth()*pBitmap->GetHeight();
  446. BYTE* pGrayScaleData = new BYTE[nPixels];
  448. UINT i=0;
  450. Rect rect(0,0,uWidth,uHeight);
  452. if(pBitmap->LockBits(&rect,ImageLockModeRead,PixelFormat32bppARGB,pBitmapData) == Ok)
  453. {
  454. Color* pLine = (Color*)pBitmapData->Scan0;
  455. Color c;
  456. UINT uPixelsPerLine = pBitmapData->Stride / 4;
  458. for(UINT row=0;row<uHeight;row++)
  459. {
  460. for(UINT col=0;col<uWidth;col++)
  461. {
  462. c = pLine[col];
  463. pGrayScaleData[i++] =(BYTE) ((double)c.GetR()*0.3 + (double)c.GetG()*0.59 + (double)c.GetB()*0.11);
  464. }
  465. pLine += uPixelsPerLine;
  467. }
  469. pBitmap->UnlockBits(pBitmapData);
  471. }
  472. delete pBitmapData;
  474. return pGrayScaleData;
  475. }
  477. void CStereoPlusDlg::OnDestroy()
  478. {
  479. CDialog::OnDestroy();
  481. theApp.WriteProfileString("Images","Left Image",m_strLeftImagePath);
  482. theApp.WriteProfileString("Images","Right Image",m_strRightImagePath);
  483. theApp.WriteProfileString("Images","Image Pair",m_strImagePairPath);
  485. }
  488. void CStereoPlusDlg::DrawBitmap(UINT idWindow,Bitmap *pBitmap)
  489. {
  490. CWnd* pWnd = GetDlgItem(idWindow);
  491. if(pWnd)
  492. {
  493. CRect rcWindow;
  494. pWnd->GetClientRect(&rcWindow);
  495. int wWindow = rcWindow.Width()-10;
  496. int hWindow = rcWindow.Height()-20;
  497. Rect rcDest(5,15,wWindow,hWindow);
  498. CDC* pDC = pWnd->GetDC();
  500. if(pBitmap)
  501. {
  502. Graphics* pGraphics = new Graphics(pDC->m_hDC);
  503.   pGraphics->ResetTransform();
  504.   pGraphics->SetInterpolationMode(InterpolationModeHighQualityBicubic);
  505. pGraphics->DrawImage(pBitmap,rcDest,0,0,pBitmap->GetWidth(),pBitmap->GetHeight(),UnitPixel);
  508. pGraphics->ReleaseHDC(pDC->m_hDC);
  509. delete pGraphics;
  510. }
  511. else
  512. {
  513. CRect rcFill(CPoint(5,15),CSize(wWindow,hWindow));
  514. pDC->FillSolidRect(rcFill,RGB(0,0,0));
  515. }
  516. ReleaseDC(pDC);
  517. }
  518. }
  520. void CStereoPlusDlg::OnSize(UINT nType, int cx, int cy)
  521. {
  522. CDialog::OnSize(nType, cx, cy);
  523. m_bSizeChanged = true;
  524. Invalidate();
  525. }
  528. void CStereoPlusDlg::ArrangeControls(void)
  529. {//Set conrol positions optimally if window is resized
  531. CRect rcHost;
  532. GetClientRect(&rcHost);
  534. int wHost = rcHost.Width();
  535. int hHost = rcHost.Height();
  536. int hImageMax = (int)(0.5 +  (double)(hHost-50)/2.0);
  538. int iSpacing = 10; 
  539. int wImage = (wHost - 3*iSpacing)/2;
  542. double dAspectRatio = 1.0/1.33;
  543. int hImage = (int)(0.5 + dAspectRatio * (double)wImage );
  545. if(hImage > hImageMax)
  546. {
  547. wImage = (int)((double)hImageMax/dAspectRatio);
  548. iSpacing = (wHost - 2*wImage)/3;
  549. hImage = hImageMax;
  551. }
  552. int iYPos = 5;
  553. int xPos = iSpacing;
  556. CRect rcControl1(CPoint(xPos,iYPos),CSize(wImage,hImage));
  557. GetDlgItem(IDC_STATIC_LEFT)->MoveWindow(&rcControl1);
  559. int iButtonWidth = rcControl1.Width()/2-20;
  561. xPos += (wImage + iSpacing);
  562. CRect rcControl2(CPoint(xPos,iYPos),CSize(wImage,hImage));
  563. GetDlgItem(IDC_STATIC_RIGHT)->MoveWindow(&rcControl2);
  565. xPos = iSpacing;
  566. iYPos = rcControl1.bottom + 10;
  567. CRect rcControl3( CPoint(xPos,iYPos),CSize(iButtonWidth,20));
  568. GetDlgItem(IDC_BUTTON_LOAD_LEFT)->MoveWindow(&rcControl3);
  570. xPos += (wImage + iSpacing);
  571. CRect rcControl4(CPoint(rcControl2.right - rcControl1.Width()/2,iYPos),CSize(iButtonWidth,20));
  572. GetDlgItem(IDC_BUTTON_LOAD_RIGHT)->MoveWindow(&rcControl4);
  574. CRect rcControl6(CPoint(wHost/2-iButtonWidth/2,iYPos),CSize(iButtonWidth,20));
  575. GetDlgItem(IDC_BUTTON_LOAD_PAIR)->MoveWindow(&rcControl6);
  577. iYPos = rcControl4.bottom + 10;
  578. CRect rcControl5(CPoint(xPos,iYPos),CSize(wImage,hImage));
  579. GetDlgItem(IDC_STATIC_DISPARITY)->MoveWindow(&rcControl5);
  582. CRect rcControlHost;
  583. GetDlgItem(IDC_STATIC_CONTROLS)->GetWindowRect(&rcControlHost);
  584. ScreenToClient(&rcControlHost);
  586. xPos = iSpacing;
  587. iYPos = rcControl4.bottom + 10;
  588. CRect rcControl7(CPoint(xPos,iYPos),CSize(wImage,hImage));
  589. GetDlgItem(IDC_STATIC_CONTROLS)->MoveWindow(&rcControl7);
  591. //this moves all the controls grouped by IDC_STATIC_CONTROLS
  592. m_SADControls.PositionControls();
  593. }
  596. //The good stuff
  597. void CStereoPlusDlg::OnBnClickedButtonDoStereo()
  598. {
  599. if(m_bNewFilesLoaded)
  600. {
  601. if(m_pLeftBitmapData) 
  602. delete [] m_pLeftBitmapData;
  604. if(m_pRightBitmapData) 
  605. delete [] m_pRightBitmapData;
  607. m_pLeftBitmapData = GetGrayScaleData(m_pLeftImageBitmap);
  608. m_pRightBitmapData = GetGrayScaleData(m_pRightImageBitmap);
  609. m_bGreyScaleDataLoaded = true;
  610. m_bNewFilesLoaded = false;
  611. }
  613. if(m_bGreyScaleDataLoaded)
  614. {
  615. UINT wL = m_pLeftImageBitmap->GetWidth();
  616. UINT hL = m_pLeftImageBitmap->GetHeight();
  618. UINT wR = m_pRightImageBitmap->GetWidth();
  619. UINT hR = m_pRightImageBitmap->GetHeight();
  621. if(wL != wR || hL != hR)
  622. {
  623. AfxMessageBox("Images need to be of similar dimension",MB_ICONSTOP | MB_OK);
  624. return;
  625. }
  627. ComputeStereo();
  628. }
  631. }
  634. // save the 3D reconstruction in 'filename'
  635. bool CStereoPlusDlg::Save3DReconst(CString filename)
  636. {
  637. return true;
  638. }
  641.  void CStereoPlusDlg::ComputeStereo(void)
  642.  {
  643. UINT w = m_pLeftImageBitmap->GetWidth();
  644. UINT h = m_pLeftImageBitmap->GetHeight();
  646. // do (SAD-based) stereo processing
  647. estereo_process(m_pStereoContext,(m_bPropagateStereo==TRUE),&m_StereoData,
  648. //((char*)m_pLeftBitmapData)-m_iImageXTranslation,
  649. ((char*)m_pLeftBitmapData),
  650. (char*)m_pRightBitmapData, w,h, -m_iImageXTranslation, m_iImageYTranslation);
  652. int disp_h, disp_w; // size of disparity image (could be different from input images)
  653. disp_w = m_StereoData.width;
  654. disp_h = m_StereoData.height;
  656. if(!m_pDisparityBitmap)
  657. {
  658. m_pDisparityBitmap = new Bitmap(disp_w,disp_h,PixelFormat32bppARGB );//don't mess with palettes Gdi+ doesn't like them
  659. }
  660. else if(m_pDisparityBitmap->GetWidth() != disp_w || m_pDisparityBitmap->GetHeight() != disp_h)
  661. {
  662. delete m_pDisparityBitmap;
  663. m_pDisparityBitmap = new Bitmap(disp_w,disp_h,PixelFormat32bppARGB );
  664. }
  666. Rect rect(0,0,disp_w,disp_h);
  667. BitmapData *pBitmapData = new BitmapData;
  669. if(m_pDisparityBitmap->LockBits(&rect,ImageLockModeWrite,PixelFormat32bppARGB,pBitmapData) == Ok)
  670. {
  671. BYTE* ptd_src = (BYTE*)m_StereoData.imDepth8u;
  673. Color* pLine = (Color*)pBitmapData->Scan0;
  674. UINT uPixelsPerLine = pBitmapData->Stride / 4;
  676. for(int row=0;row<disp_h;row++)
  677. {
  678. for(int col=0;col<disp_w;col++)
  679. {
  680. if (*ptd_src>0)
  681. {
  682. BYTE lum = 50 + *ptd_src*4; 
  683. pLine[col] = Color::MakeARGB(255,lum,lum,lum);
  684. }
  685. else
  686. {
  687. pLine[col] = Color::MakeARGB(255,0,0,0);
  688. }
  690. ptd_src++;
  691. }
  692. pLine += uPixelsPerLine;
  694. }
  696. m_pDisparityBitmap->UnlockBits(pBitmapData);
  698. }
  699. delete pBitmapData;
  702. DrawBitmap(IDC_STATIC_DISPARITY,m_pDisparityBitmap);
  704.  }
  707. void CStereoPlusDlg::estereo_process(StereoMatching* stereo, bool propag_stereo,
  708.   StereoImage* simage,
  709.   const char* imLeft, const char* imRight, 
  710.   int width, int height, int xOffset, int yOffset)
  711. {
  712. // set the 'undefined depth' value to 0
  713. simage->setUndefinedDepthValue(0);
  715. // do the disparity calculation - SAD
  716. stereo->setInputImageSize(width, height);
  717. stereo->setLeftImageXOffset(xOffset);
  718. stereo->setLeftImageYOffset(yOffset);
  719. // set monoscale/multiscale processing
  720. stereo->setScaleProcessing(propag_stereo?StereoMatching::MULTISCALE 
  721. : StereoMatching::MONOSCALE);
  722. stereo->doStereo(simage, (const unsigned char*)imLeft, (const unsigned char*)imRight);
  723. }
  728. void CStereoPlusDlg::InitStereoContext()
  729. {
  730. // *********************************************
  731. // ******** initialize disparity estimation context
  732. m_pStereoContext = new StereoMatching();
  733. // initialize SAD parameters
  734. m_pStereoContext->setHoropter(m_iHoropter);
  735. m_pStereoContext->setNumDepth(m_iDisparityRange);
  736. m_pStereoContext->setCorrelationWindowSize(m_iCorrelationWindow,m_iCorrelationWindow);
  737. m_pStereoContext->setInputImageSize(320,240);
  738. m_pStereoContext->setScale(m_iDisparityImageScale);
  739. m_pStereoContext->setAcceptDisparityThreshold((float)m_iSADThreshold);
  740. // allocate buffers for SAD computation
  741. m_pStereoContext->initializeContext();
  742. }
  744. void CStereoPlusDlg::OnDeltaposSpinDisparityrange(NMHDR *pNMHDR, LRESULT *pResult)
  745. {
  746. LPNMUPDOWN pNMUpDown = reinterpret_cast<LPNMUPDOWN>(pNMHDR);
  747. if(UpdateData())
  748. {
  750. m_iDisparityRange -= 8*pNMUpDown->iDelta;
  751. m_iDisparityRange = max(MIN_DISPARITY_RANGE,min(MAX_DISPARITY_RANGE,m_iDisparityRange));
  752. UpdateData(FALSE);
  754. if(m_pStereoContext)
  755. m_pStereoContext->setNumDepth(m_iDisparityRange);
  757. if (m_bGreyScaleDataLoaded) 
  758. {
  759. ComputeStereo();
  760. }
  761. }
  763. *pResult = 0;
  764. }
  766. void CStereoPlusDlg::OnDeltaposSpinHoropter(NMHDR *pNMHDR, LRESULT *pResult)
  767. {
  768. LPNMUPDOWN pNMUpDown = reinterpret_cast<LPNMUPDOWN>(pNMHDR);
  769. if(UpdateData())
  770. {
  771. m_iHoropter -= pNMUpDown->iDelta;
  772. m_iHoropter = max(MIN_HOROPTER,min(MAX_HOROPTER,m_iHoropter));
  773. UpdateData(FALSE);
  775. if(m_pStereoContext)
  776. m_pStereoContext->setHoropter(m_iHoropter);
  778. if (m_bGreyScaleDataLoaded) 
  779. {
  780. ComputeStereo();
  781. }
  782. }
  783. *pResult = 0;
  784. }
  786. void CStereoPlusDlg::OnDeltaposSpinCorrwinsize(NMHDR *pNMHDR, LRESULT *pResult)
  787. {
  788. LPNMUPDOWN pNMUpDown = reinterpret_cast<LPNMUPDOWN>(pNMHDR);
  790. if(UpdateData())
  791. {
  793. m_iCorrelationWindow -= 2*pNMUpDown->iDelta;
  794. m_iCorrelationWindow = max(MIN_CORRELATION_WINDOW,min(MAX_CORRELATION_WINDOW,m_iCorrelationWindow));
  795. UpdateData(FALSE);
  797. if(m_pStereoContext)
  798. m_pStereoContext->setCorrelationWindowSize(m_iCorrelationWindow,m_iCorrelationWindow);
  800. if (m_bGreyScaleDataLoaded) 
  801. {
  802. ComputeStereo();
  803. }
  804. }
  807. // TODO: Add your control notification handler code here
  808. *pResult = 0;
  809. }
  811. void CStereoPlusDlg::OnDeltaposSpinSadthresh(NMHDR *pNMHDR, LRESULT *pResult)
  812. {
  813. LPNMUPDOWN pNMUpDown = reinterpret_cast<LPNMUPDOWN>(pNMHDR);
  814. if(UpdateData())
  815. {
  816. m_iSADThreshold -= pNMUpDown->iDelta;
  817. m_iSADThreshold = max(MIN_SAD_THRESHOLD,min(MAX_SAD_THRESHOLD,m_iSADThreshold));
  818. UpdateData(FALSE);
  820. if(m_pStereoContext)
  821. m_pStereoContext->setAcceptDisparityThreshold((float)m_iSADThreshold);
  823. if (m_bGreyScaleDataLoaded) 
  824. {
  825. ComputeStereo();
  826. }
  827. }
  829. *pResult = 0;
  830. }
  832. void CStereoPlusDlg::OnDeltaposSpinDisparityscale(NMHDR *pNMHDR, LRESULT *pResult)
  833. {
  834. LPNMUPDOWN pNMUpDown = reinterpret_cast<LPNMUPDOWN>(pNMHDR);
  835. if(UpdateData())
  836. {
  838. m_iDisparityImageScale -= pNMUpDown->iDelta;
  839. m_iDisparityImageScale = max(MIN_DISPARITY_IMAGE_SCALE,min(MAX_DISPARITY_IMAGE_SCALE,m_iDisparityImageScale));
  840. UpdateData(FALSE);
  842. if(m_pStereoContext)
  843. m_pStereoContext->setScale(m_iDisparityImageScale);
  845. if (m_bGreyScaleDataLoaded) 
  846. {
  847. ComputeStereo();
  848. }
  849. }
  850. *pResult = 0;
  851. }
  853. void CStereoPlusDlg::OnBnClickedCheckStereoPropagation()
  854. {
  856. if(UpdateData())
  857. {
  858. if(m_bPropagateStereo)
  859. OutputDebugString("Stereo Propagation is ONn");
  860. else
  861. OutputDebugString("Stereo Propagation is OFFn");
  863. if (m_bGreyScaleDataLoaded) 
  864. {
  865. ComputeStereo();
  866. }
  867. }
  869. }
  875. void CStereoPlusDlg::OnClose()
  876. {
  877. m_bClosing = true;
  879. CDialog::OnClose();
  880. }
  883. // build the 3D reconstruction and display it using directX
  884. void CStereoPlusDlg::OnBnClickedButtonDoReconstructionDirectx()
  885. {
  886. if(!UpdateData())
  887. return;
  889. // create a '3D reconstruction' structure
  890. if(m_pPts3d)
  891. delete m_pPts3d;
  892. m_pPts3d = new ReconstPoints3D();
  894. // set virtual camera parameters
  895. m_Reconst3d.setCameraParameters(m_fFocalLength,m_fBaseLine,
  896. (float)(m_StereoData.width/2),
  897. (float)(m_StereoData.height/2));
  898. // perform the 3D reconstruction
  899. switch(m_Reconst3d.doReconstruction(m_pPts3d,&m_StereoData,m_pRightImageBitmap))
  900. {
  901. case Reconst3D::RECONST_OK: {
  902. CDirectXDialog DirectXDlg(this);
  903. DirectXDlg.SetData( m_pPts3d->getNumPoints(),
  904. m_pPts3d->getXlist(),
  905. m_pPts3d->getYlist(),
  906. m_pPts3d->getZlist(),
  907. m_pPts3d->getARGBlist(),
  908. m_pPts3d->getPointSizelist());
  909. DirectXDlg.DoModal();
  910. }
  911. break;
  912.   
  913. //
  914. case Reconst3D::CAMERA_PARAM_NOT_SET:
  915. AfxMessageBox("Set cam parameters before attempting reconstruction",MB_ICONEXCLAMATION);
  916. break;
  918. case Reconst3D::IMAGE_BUFFER_NULL:
  919. AfxMessageBox("Set the image buffer before attempting reconstruction",MB_ICONEXCLAMATION);
  920. break;
  922. case Reconst3D::WRONG_IMAGE_SIZE:
  923. AfxMessageBox("Image size doesn't match the SAD data",MB_ICONEXCLAMATION);
  924. break;
  925. }
  933. }
  935. void CStereoPlusDlg::OnBnClickedCheckSwap()
  936. {
  937. if(UpdateData())
  938. {
  939. if(m_bImagesAreSwapped != m_bSwapLeftRight)
  940. SwapImages();
  942. m_bImagesAreSwapped = m_bSwapLeftRight;
  943. }
  944. }
  947. void CStereoPlusDlg::SwapImages(void)
  948. {
  949. if(m_pLeftImageBitmap && m_pRightImageBitmap)
  950. {
  951. Bitmap* pLeft = m_pLeftImageBitmap;
  952. Bitmap* pRight = m_pRightImageBitmap;
  953. BYTE* pLeftData = m_pLeftBitmapData;
  954. BYTE* pRightData = m_pRightBitmapData;
  956. m_pLeftImageBitmap = pRight;
  957. m_pRightImageBitmap = pLeft;
  959. m_pLeftBitmapData = pRightData;
  960. m_pRightBitmapData = pLeftData;
  962. DrawBitmap(IDC_STATIC_LEFT,m_pLeftImageBitmap);
  963. DrawBitmap(IDC_STATIC_RIGHT,m_pRightImageBitmap);
  965. ComputeStereo();
  966. }
  967. }
  970. void CStereoPlusDlg::OnBnClickedCheckResample()
  971. {
  972. m_bResample = (m_ctrlResampleImages.GetCheck() == BST_CHECKED);
  974. m_ctrlEditResampleWidth.EnableWindow(m_bResample);
  976. if(m_bResample && (m_pLeftImageBitmap || m_pRightImageBitmap) )
  977. AfxMessageBox("Re-Load images to apply resampling",MB_ICONINFORMATION);
  978. }
  980. void CStereoPlusDlg::OnDeltaposSpinXtranslate(NMHDR *pNMHDR, LRESULT *pResult)
  981. {
  982. LPNMUPDOWN pNMUpDown = reinterpret_cast<LPNMUPDOWN>(pNMHDR);
  983. if(UpdateData())
  984. {
  985. m_iImageXTranslation -= pNMUpDown->iDelta;
  986. m_iImageXTranslation = max(-128,min(128,m_iImageXTranslation));
  987. UpdateData(FALSE);
  989. if (m_bGreyScaleDataLoaded) {
  990. ComputeStereo();
  991. }
  992. }
  993. // TODO: Add your control notification handler code here
  994. *pResult = 0;
  995. }
  997. void CStereoPlusDlg::OnDeltaposSpinYtranslate(NMHDR *pNMHDR, LRESULT *pResult)
  998. {
  999. LPNMUPDOWN pNMUpDown = reinterpret_cast<LPNMUPDOWN>(pNMHDR);
  1000. if(UpdateData())
  1001. {
  1002. m_iImageYTranslation -= pNMUpDown->iDelta;
  1003. m_iImageYTranslation = max(-128,min(128,m_iImageYTranslation));
  1004. UpdateData(FALSE);
  1006. if (m_bGreyScaleDataLoaded) {
  1007. ComputeStereo();
  1008. }
  1009. }
  1010. // TODO: Add your control notification handler code here
  1011. *pResult = 0;
  1012. }
  1014. int GetEncoderClsid(const WCHAR* format, CLSID* pClsid)
  1015. {
  1016.    UINT  num = 0;          // number of image encoders
  1017.    UINT  size = 0;         // size of the image encoder array in bytes
  1019.    ImageCodecInfo* pImageCodecInfo = NULL;
  1021.    GetImageEncodersSize(&num, &size);
  1022.    if(size == 0)
  1023.       return -1;  // Failure
  1025.    pImageCodecInfo = (ImageCodecInfo*)(malloc(size));
  1026.    if(pImageCodecInfo == NULL)
  1027.       return -1;  // Failure
  1029.    GetImageEncoders(num, size, pImageCodecInfo);
  1031.    for(UINT j = 0; j < num; ++j)
  1032.    {
  1033.       if( wcscmp(pImageCodecInfo[j].MimeType, format) == 0 )
  1034.       {
  1035.          *pClsid = pImageCodecInfo[j].Clsid;
  1036.          free(pImageCodecInfo);
  1037.          return j;  // Success
  1038.       }    
  1039.    }
  1041.    free(pImageCodecInfo);
  1042.    return -1;  // Failure
  1043. }
  1045. void CStereoPlusDlg::OnBnClickedButtonSavedisparity()
  1046. {
  1047. // TODO: Add your control notification handler code here
  1049. // save m_pDisparityBitmap
  1050. CString FilePath = m_strLeftImagePath;
  1051. CFileDialog* pFileDlg = new CThumbnailFileDialog(FALSE,"jpg",NULL,
  1052. OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT|OFN_FILEMUSTEXIST,
  1053. "Image Files (*.jpg) |*.jpg| All Files (*.*) |*.*||", 
  1054. // "Image Files (*.jpg;*.jps,*.bmp) |*.jpg;*.jps;*.bmp| All Files (*.*) |*.*||", 
  1055. AfxGetMainWnd() );
  1057. char drive[_MAX_DRIVE];
  1058. char dir[_MAX_DIR]; 
  1059. char fname[_MAX_FNAME];
  1060. char ext[_MAX_EXT];
  1062. CString FileDir;
  1063. _splitpath( FilePath, drive, dir, fname, ext );
  1064. if(strlen(drive) != 0)FileDir = drive;
  1065. if(strlen(dir) != 0)FileDir += dir;
  1067. pFileDlg->m_ofn.nFilterIndex = 0;
  1068. pFileDlg->m_ofn.lpstrInitialDir = FileDir;
  1069. pFileDlg->m_ofn.lpstrTitle = "Select Image";
  1070. CString InitialFileName = fname;
  1072. lstrcpy(pFileDlg->m_ofn.lpstrFile,InitialFileName);
  1074. BOOL FileSelected = FALSE;
  1076. if(pFileDlg->DoModal() == IDOK)
  1077. {
  1078. FilePath = pFileDlg->GetPathName();
  1079. FileSelected = TRUE;
  1080. CString strPathName = FilePath;
  1081. CLSID clsid;
  1082.     GetEncoderClsid(L"image/jpeg", &clsid);
  1083. Status status = m_pDisparityBitmap->Save(strPathName.AllocSysString(), &clsid);
  1084. if(Ok != status)
  1085. {
  1086. TRACE2(_T("nFailed to save image in '%s' filen")
  1087. _T("GDI+ Error: %u"),
  1088. strPathName,
  1089. status);
  1090. }
  1091. }
  1093. delete pFileDlg;
  1094. pFileDlg = NULL;
  1095. }