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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 视频捕捉/采集 > 查看源码
test2eyesDlg.cpp
资源名称：test2eyes_201004251108.rar　[点击查看]
上传用户：lwxipeng
上传日期：2022-05-16
资源大小：15982k
文件大小：25k
源码类别：

视频捕捉/采集

开发平台：

Visual C++

test2eyesDlg.cpp：源码内容
  1. // test2eyesDlg.cpp : 实现文件
  2. //
  4. #include "stdafx.h"
  5. #include "test2eyes.h"
  6. #include "test2eyesDlg.h"
  8. //---OpenCV的库文件-----------
  9. #pragma comment (lib,"cv200d")
  10. #pragma comment (lib,"highgui200d")
  11. #pragma comment (lib, "cxcore200d")
  13. //---gsl的库文件-----------
  14. #pragma comment (lib, "libgsl.a")
  18. #include "sift.h"
  19. #include "imgfeatures.h"
  20. #include "kdtree.h"
  21. #include "utils.h"
  22. #include "xform.h"
  24. #include <Windows.h>
  25. #include <cv.h>
  26. #include <cxcore.h>
  27. #include <highgui.h>
  29. #include <stdio.h>
  30. #include <math.h>
  32. // #include   <mmsystem.h>   
  33. // #pragma   comment(lib,   "WINMM.LIB") 
  35. #ifdef _DEBUG
  36. #define new DEBUG_NEW
  37. #endif
  39. // Ctest2eyesDlg 对话框
  41. #define MYTIMER 3
  43. Ctest2eyesDlg::Ctest2eyesDlg(CWnd* pParent /*=NULL*/)
  44. : CDialog(Ctest2eyesDlg::IDD, pParent)
  45. {
  46. m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
  47. }
  49. Ctest2eyesDlg::~Ctest2eyesDlg()
  50. {
  52. m_ThreadExit = TRUE;
  53. //------释放内存存储器-----------
  54. cvReleaseImage( &stacked );
  55. cvReleaseImage( &img1 );
  56. cvReleaseImage( &img2 );
  57. kdtree_release( kd_root );
  58. free( feat1 );
  59. free( feat2 );
  60. }
  62. void Ctest2eyesDlg::DoDataExchange(CDataExchange* pDX)
  63. {
  64. CDialog::DoDataExchange(pDX);
  65. DDX_Control(pDX, IDC_SLIDER1, m_slider);
  67. }
  69. BEGIN_MESSAGE_MAP(Ctest2eyesDlg, CDialog)
  70. ON_WM_PAINT()
  71. ON_WM_QUERYDRAGICON()
  72. //}}AFX_MSG_MAP
  73. ON_BN_CLICKED(IDOK, &Ctest2eyesDlg::OnBnClickedOk)
  74. ON_NOTIFY(NM_RELEASEDCAPTURE, IDC_SLIDER1, &Ctest2eyesDlg::OnNMReleasedcaptureSlider1)
  76. ON_WM_TIMER()
  78. ON_WM_CTLCOLOR()
  79. ON_BN_CLICKED(IDCANCEL, &Ctest2eyesDlg::OnBnClickedCancel)
  80. END_MESSAGE_MAP()
  83. // Ctest2eyesDlg 消息处理程序
  85. BOOL Ctest2eyesDlg::OnInitDialog()
  86. {
  87. CDialog::OnInitDialog();
  89. // 设置此对话框的图标。当应用程序主窗口不是对话框时，框架将自动
  90. //  执行此操作
  91. SetIcon(m_hIcon, TRUE); // 设置大图标
  92. SetIcon(m_hIcon, FALSE); // 设置小图标
  101. CString strsj;
  103. m_sj = (CEdit*)this->GetDlgItem( IDC_EDIT_SJ );
  105. strsj= _T("70");
  107. m_sj->SetWindowText( strsj);
  109. CString strjj;
  111. m_jj = (CEdit*)this->GetDlgItem( IDC_EDIT_JJ );
  113. strjj= _T("370");
  115. m_jj->SetWindowText( strjj);
  117. CString strmin;
  119. m_min = (CEdit*)this->GetDlgItem( IDC_EDIT_MIN );
  121. strmin= _T("20");
  123. m_min->SetWindowText( strmin);
  125. CString strmax;
  127. m_max = (CEdit*)this->GetDlgItem( IDC_EDIT_MAX );
  129. strmax= _T("1000");
  131. m_max->SetWindowText( strmax);
  136. m_slider.SetRange(1,30,TRUE);
  137. m_slider.SetPos(3);
  138. CString m_LIP,m_RIP;
  139. m_LIP= _T("192.168.10.46");
  140. m_RIP= _T("192.168.10.47");
  141. m_RightReceived = FALSE;
  142. m_LeftReceived= FALSE;
  143. m_processing= FALSE;
  144. m_ThreadExit = TRUE;
  145. m_lip = (CEdit*)this->GetDlgItem( IDC_EDIT_L );
  146. m_rip = (CEdit*)this->GetDlgItem( IDC_EDIT_R );
  147. m_lip->SetWindowText( m_LIP);
  148. m_rip->SetWindowText( m_RIP);
  150. m_pos = 5;
  153. stacked = NULL;
  154. memset(m_ju,0,sizeof(struct des)*1000);
  155. memset(m_out_ju,0,sizeof(struct des)*1000);
  156. m_ju_k = 0;
  157. m_yu_zhi_enable =FALSE;
  160. // TODO: 在此添加额外的初始化代码
  161. m_BMPDisplayBrush.DeleteObject();
  162. m_BMPDisplayBrush.CreateSolidBrush(RGB(255,255,255));
  164. m_BMP_OK.LoadBitmap(IDB_BITMAP_OK);
  165. m_BMP_NG.LoadBitmap(IDB_BITMAP_NG);
  166. m_BMP_WAIT.LoadBitmap(IDB_BITMAP_WAIT);
  167. GetDlgItem(IDC_STATIC_ICON)->MoveWindow(10,10,50,50);
  168. GetDlgItem(IDC_STATIC_ICON)->GetWindowRect(m_BMPDisplayRect);
  169. ScreenToClient(m_BMPDisplayRect);
  170. ShowICON(0);
  174. return TRUE;  // 除非将焦点设置到控件，否则返回 TRUE
  175. }
  177. void Ctest2eyesDlg::OnPaint()
  178. {
  179. if (IsIconic())
  180. {
  181. CPaintDC dc(this); // 用于绘制的设备上下文
  183. SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);
  185. // 使图标在工作矩形中居中
  186. int cxIcon = GetSystemMetrics(SM_CXICON);
  187. int cyIcon = GetSystemMetrics(SM_CYICON);
  188. CRect rect;
  189. GetClientRect(&rect);
  190. int x = (rect.Width() - cxIcon + 1) / 2;
  191. int y = (rect.Height() - cyIcon + 1) / 2;
  193. // 绘制图标
  194. dc.DrawIcon(x, y, m_hIcon);
  195. }
  196. else
  197. {
  198. CDialog::OnPaint();
  199. }
  200. }
  202. void Ctest2eyesDlg::ShowICON(int nicon)
  203. {
  204. if (nicon == 0)
  205. {
  206. m_BMPDisplayBrush.DeleteObject();
  207. m_BMPDisplayBrush.CreatePatternBrush(&m_BMP_WAIT);
  208. InvalidateRect(m_BMPDisplayRect,FALSE);
  209. } 
  210. if (nicon == 1)
  211. {
  212. m_BMPDisplayBrush.DeleteObject();
  213. m_BMPDisplayBrush.CreatePatternBrush(&m_BMP_OK);
  214. InvalidateRect(m_BMPDisplayRect,FALSE);
  215. }
  216. if (nicon == 2)
  217. {
  218. m_BMPDisplayBrush.DeleteObject();
  219. m_BMPDisplayBrush.CreatePatternBrush(&m_BMP_NG);
  220. InvalidateRect(m_BMPDisplayRect,FALSE);
  221. }
  222. }
  223. //当用户拖动最小化窗口时系统调用此函数取得光标显示。
  224. //
  225. HCURSOR Ctest2eyesDlg::OnQueryDragIcon()
  226. {
  227. return static_cast<HCURSOR>(m_hIcon);
  228. }
  231. void Ctest2eyesDlg::OnBnClickedOk()
  232. {
  233. m_ThreadExit = FALSE;
  234. AfxBeginThread( ThreadL , this );
  235. AfxBeginThread( ThreadR , this );
  237. SetTimer( MYTIMER , 500 , NULL );
  238. }
  240. void Ctest2eyesDlg::test_SIFT()
  241. {
  242. //  if (m_RightReceived == FALSE ||  m_LeftReceived == FALSE )
  243. //  {
  244. //  return ;
  245. //  }
  246. m_processing = TRUE;
  248. TRACE(_T("Processing One...rn"));
  250. ShowICON(0);
  251. int l=0;
  252. if(l<5)
  253. l=4;
  256. char   img1_file[] = "D:\project\pic\001.jpg";
  257. char   img2_file[] = "D:\project\pic\002.jpg" ;
  259. double imgzoom_scale=1.0;
  261. struct feature* feat;
  262. struct feature** nbrs;
  264. CvPoint pt1 ={0,0}, pt2={0,0};
  265. double d0, d1;
  266. int n1, n2, k, i;
  268. static int m = 0;
  270. //cvReleaseImage(&img1);
  271. img1 = cvLoadImage( img1_file, 1 );
  272. if( ! img1 )
  273. {
  274. //fatal_error( "unable to load image from %s", img1_file );
  275. CString strerr;
  276. strerr.Format(_T("unable to load image from img1.rn"));
  277. TRACE(strerr);
  278. }
  280. //cvReleaseImage(&img2);
  281. img2 = cvLoadImage( img2_file, 1 );
  282. if( ! img2 )
  283. {
  284. CString strerr;
  285. strerr.Format(_T("unable to load image from img2.rn"));
  286. TRACE(strerr);
  287. }
  290. stacked = stack_imgs( img1, img2 );
  291. n1 = sift_features( img1, &feat1 );
  292. n2 = sift_features( img2, &feat2 );
  294. kd_root = kdtree_build( feat2, n2 );
  296. m_ju_k = 0;
  297. for( i = 0; i < n1; i++ )
  298. {
  299. feat = feat1 + i;
  300. k = kdtree_bbf_knn( kd_root, feat, 2, &nbrs, KDTREE_BBF_MAX_NN_CHKS );
  301. if( k == 2 )
  302. {
  303. d0 = descr_dist_sq( feat, nbrs[0] );
  304. d1 = descr_dist_sq( feat, nbrs[1] );
  305. if( d0 < d1 * NN_SQ_DIST_RATIO_THR )
  306. {
  307. pt1 = cvPoint( cvRound( feat->x ), cvRound( feat->y ) );
  308. pt2 = cvPoint( cvRound( nbrs[0]->x ), cvRound( nbrs[0]->y ) );
  310. //---------存储单个点坐标到点序列中----------
  312. pt2.x += img1->width + 20;
  313. m_ju[m_ju_k].y = abs(pt1.y - pt2.y);
  315. m_ju[m_ju_k].lx = pt1.x;
  316. m_ju[m_ju_k].ly = pt1.y;
  317. m_ju[m_ju_k].rx = pt2.x;
  318. m_ju[m_ju_k].ry = pt2.y;
  319. m_ju[m_ju_k].x = abs(pt2.x - pt1.x - img1->width - 20);
  320. m_ju[m_ju_k].s = m_ju[m_ju_k].x;
  321. CString str1;
  323. m_sj->GetWindowText(str1);
  325. ULONG sj;
  327. sj = _ttoi(str1.GetBuffer());;
  328. CString str2;
  330. m_jj->GetWindowText(str2);
  332. ULONG jj;
  334. jj = _ttoi(str2.GetBuffer());
  335. if ( jj != 0 && sj != 0)
  336. {
  337. int z;
  338. z=jj*sj;
  339. if (m_ju[m_ju_k].s!=0)
  340. {
  341. m_ju[m_ju_k].L_des = z/m_ju[m_ju_k].s;
  342. }
  343. m_ju_k++;
  344. }
  345. }
  346. }
  347. free( nbrs );
  348. }
  349. m_yu_zhi_enable =TRUE;
  352. Yu_Zhi();
  354. TRACE(_T("Processing One OK.rn"));
  355. return ;
  357. }
  358. void Ctest2eyesDlg::Yu_Zhi()
  359. {
  360. TRACE(_T("Processing Two.rn"));
  361. if (m_yu_zhi_enable == TRUE)
  362. {
  363. BOOL findsth = FALSE;
  364. for (int dota = 0;dota < m_ju_k; dota++)
  365. {
  366. CString str_min,str_max;
  367. m_max->GetWindowText(str_max);
  368. m_min->GetWindowText(str_min);
  369. ULONG  mmax,mmin;
  370. mmax = _ttoi(str_max.GetBuffer());
  371. mmin = _ttoi(str_min.GetBuffer());
  372. if ((m_ju[dota].L_des>mmin) && (m_ju[dota].L_des<mmax) && (m_ju[dota].y<7))
  374. {
  375. findsth =TRUE;
  376. // PlaySound(__T("D:\dfa.wma"),NULL,SND_ASYNC|SND_LOOP);
  377. TRACE(_T("imag1 cood:%3d,%3drn"),m_ju[dota].lx,m_ju[dota].ly);
  378. TRACE(_T("imag2 cood:%3d,%3drn"),m_ju[dota].rx,m_ju[dota].ry);
  379. TRACE(_T("destence:%5drn"),m_ju[dota].L_des);
  380. cvRectangle(stacked,cvPoint(m_ju[dota].lx - m_ju[dota].s/m_pos,m_ju[dota].ly - m_ju[dota].s/m_pos),cvPoint(m_ju[dota].lx + m_ju[dota].s/m_pos,m_ju[dota].ly + m_ju[dota].s/m_pos),CV_RGB(255,0,0),1,8,0);    
  381. cvRectangle(stacked,cvPoint(m_ju[dota].rx - m_ju[dota].s/m_pos,m_ju[dota].ry - m_ju[dota].s/m_pos),cvPoint(m_ju[dota].rx + m_ju[dota].s/m_pos,m_ju[dota].ry + m_ju[dota].s/m_pos),CV_RGB(255,0,0),1,8,0);
  382. dota++;
  383. }
  385. }
  386. if (findsth)
  387. {
  388. ShowICON(2);
  389. }
  390. else
  391. {
  392. ShowICON(1);
  393. }
  396. cvDestroyAllWindows;
  397. cvNamedWindow( "img_feature", 1 );
  398. cvShowImage( "img_feature", stacked );
  400. cvReleaseImage( &stacked );
  401. cvReleaseImage( &img1 );
  402. cvReleaseImage( &img2 );
  403. kdtree_release( kd_root );
  404. free( feat1 );
  405. free( feat2 );
  406. m_RightReceived = FALSE;
  407. m_LeftReceived = FALSE;
  408. m_processing = FALSE;
  409. TRACE(_T("Processing Two OK.rn"));
  410. }
  411. m_yu_zhi_enable = FALSE;
  413. }
  417. void Ctest2eyesDlg::OnNMReleasedcaptureSlider1(NMHDR *pNMHDR, LRESULT *pResult)
  418. {
  419. m_pos=m_slider.GetPos();
  420. Yu_Zhi();
  421. *pResult = 0;
  422. }
  425. UINT ThreadR( LPVOID g)
  426. {
  427. WSADATA wsa;
  428. /* initialize socket  */
  429. WSAStartup(MAKEWORD(1,1),&wsa);
  430. Ctest2eyesDlg * thisClass = (Ctest2eyesDlg*)g;
  432. SOCKET m_serverSocket;
  435. /* create socket  */
  436. m_serverSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  438. SOCKADDR_IN  serverAddr;
  439. ZeroMemory((char *)&serverAddr,sizeof(serverAddr));
  440. serverAddr.sin_family = AF_INET;
  441. serverAddr.sin_port = htons(5565);
  442. serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
  444. /* bind socket  */
  445. bind(m_serverSocket, (struct sockaddr *)&serverAddr, sizeof(serverAddr));
  447. struct sockaddr_in daddr; 
  448. memset((void *)&daddr,0,sizeof(daddr)); 
  449. daddr.sin_family=AF_INET; 
  450. daddr.sin_port=htons(80);
  452. CString str1 ;
  454. thisClass->m_rip->GetWindowText(str1);
  456. char rip[40];
  458. wcstombs(rip , str1.GetBuffer() , 39 );
  461. daddr.sin_addr.s_addr=inet_addr(rip); 
  462. int error = connect(m_serverSocket,(struct sockaddr *)&daddr,sizeof(daddr)); 
  463. const char * buf = "GET /MJPEG.CGI HTTP/1.0rnrn";
  466. fd_set fdRead; /* Read concourse define. */
  467. int ret; /* Return value. */
  468. TIMEVAL aTime; /* Event wait time define. */
  470. char recvBuf[RECV_BUF_SIZE];
  471. int allcount = 0;
  473. aTime.tv_sec = 1;
  474. aTime.tv_usec = 0;
  476. int recvLen;
  478. int f_recv = F_RECEIVE_NOWORKR;
  480. send( m_serverSocket,buf,100,0);
  482. TRACE(__T("Right Socket ok.rn"));
  483. while (thisClass->m_ThreadExit == FALSE)
  484. {
  485. if (thisClass->m_RightReceived == TRUE)
  486. {
  487. TRACE(__T("Right Wait for Processing.rn"));
  488. Sleep(10);
  489. continue;
  490. }
  491. TRACE(__T("Right Receiving.rn"));
  492. /* Set empty to the fdRead Event. */
  493. FD_ZERO(&fdRead);
  495. /* Set read event to the client socket. */
  496. FD_SET(m_serverSocket,&fdRead);
  498. /* To judge whether there is any read event. */
  499. ret = select(0,&fdRead,NULL,NULL,&aTime);
  500. if (ret > 0)
  501. {
  503. if (FD_ISSET(m_serverSocket,&fdRead))
  504. {
  505. /* read event happen */
  506. recvLen = 0;
  508. /* recieve data */
  509. memset( recvBuf , 0 , RECV_BUF_SIZE );
  510. recvLen = recv( m_serverSocket , recvBuf , RECV_BUF_SIZE , 0 );
  512. if( recvLen <= 0 )
  513. {
  514. TRACE( _T( "Right TCP recive nothing.rn" ) );
  515. continue;
  516. }
  518. if( F_RECEIVE_NOWORKR == f_recv )
  519. {
  520. int tempcount;
  521. for( tempcount = 0 ; tempcount < recvLen - 1 ; tempcount++ )
  522. {
  523. if( ( recvBuf[tempcount] == (char)0xFF ) && ( recvBuf[tempcount + 1] == (char)0xD8 ) )
  524. {
  525. f_recv = F_RECEIVE_BEGINR;
  526. break;
  527. }                        
  528. }
  530. if(  F_RECEIVE_BEGINR == f_recv )
  531. {
  532. f_recv = F_RECEIVE_R;
  533. thisClass->recvBytePointerR = 0;
  534. memcpy( thisClass->recvImageBufR , recvBuf + tempcount , recvLen - tempcount );
  535. thisClass->recvBytePointerR = recvLen - tempcount;
  536. }
  537. }
  538. else if( F_RECEIVE_R == f_recv )
  539. {
  540. int tempcount;
  541. for( tempcount = 0 ; tempcount < recvLen  ; tempcount++ )
  542. {
  543. if( ( recvBuf[tempcount - 2] == (char)0xFF ) && ( recvBuf[tempcount - 1] == (char)0xD9 ) )
  544. {
  545. f_recv = F_RECEIVE_OVERR;
  546. break;
  547. }
  548. }
  550. if( F_RECEIVE_R == f_recv )   /* 未接收完一个文件 */
  551. {
  552. memcpy( thisClass->recvImageBufR + thisClass->recvBytePointerR , recvBuf , recvLen );
  553. thisClass->recvBytePointerR += recvLen;
  554. }
  555. else if( F_RECEIVE_OVERR == f_recv ) /* 接收完一个文件 */
  556. {           
  559. memcpy( thisClass->recvImageBufR + thisClass->recvBytePointerR , recvBuf , tempcount );
  560. thisClass->recvBytePointerR += tempcount;
  562. CString strL;
  564. strL.Format( __T("D:\project\pic\001.jpg") , 1 );
  566. TRACE(__T("Right Received file.rn"));
  567. CFile ka;
  568. if( ka.Open( strL , CFile::modeCreate | CFile::modeReadWrite ) == TRUE )
  569. {
  570. TRACE(__T("Right Writting file.rn"));
  571. ka.SeekToBegin();
  572. ka.Write( thisClass->recvImageBufR , thisClass->recvBytePointerR );
  573. ka.Close();
  574. thisClass->m_RightReceived = TRUE;
  575. }
  576. TRACE(__T("Right Received done.rn"));
  578. if( thisClass->f_MutexImageBufR == MUTEX_NONUSE )
  579. {
  580. thisClass->f_MutexImageBufR = MUTEX_USE;
  581. memcpy(thisClass->imageBufR.buf , thisClass->recvImageBufR , thisClass->recvBytePointerR );
  584. thisClass->imageBufR.size = thisClass->recvBytePointerR;
  585. thisClass->f_MutexImageBufR = MUTEX_NONUSE;
  586. }
  588. f_recv = F_RECEIVE_NOWORKR;
  590. for( ; tempcount < recvLen - 1 ; tempcount++ )
  591. {
  592. if( ( recvBuf[tempcount] == (char)0xFF ) && ( recvBuf[tempcount + 1] == (char)0xD8 ) )
  593. {
  594. f_recv = F_RECEIVE_BEGINR;
  595. break;
  596. }                        
  597. }
  599. if(  F_RECEIVE_BEGINR == f_recv )
  600. {
  601. f_recv = F_RECEIVE_R;
  602. thisClass->recvBytePointerR = 0;
  603. memcpy( thisClass->recvImageBufR , recvBuf + tempcount , recvLen - tempcount );
  604. thisClass->recvBytePointerR = recvLen - tempcount;
  605. }
  607. }
  608. }
  609. }
  610. }
  612. }
  615. closesocket(m_serverSocket);
  616. WSACleanup();
  618. return TRUE;
  619. }
  621. UINT ThreadL( LPVOID g)
  622. {
  623. WSADATA wsa;
  624. /* initialize socket  */
  625. WSAStartup(MAKEWORD(1,1),&wsa);
  626. Ctest2eyesDlg * thisClass = (Ctest2eyesDlg*)g;
  628. SOCKET m_serverSocket;
  631. /* create socket  */
  632. m_serverSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  634. SOCKADDR_IN  serverAddr;
  635. ZeroMemory((char *)&serverAddr,sizeof(serverAddr));
  636. serverAddr.sin_family = AF_INET;
  637. serverAddr.sin_port = htons(5565);
  638. serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
  640. /* bind socket  */
  641. bind(m_serverSocket, (struct sockaddr *)&serverAddr, sizeof(serverAddr));
  643. struct sockaddr_in daddr; 
  644. memset((void *)&daddr,0,sizeof(daddr)); 
  645. daddr.sin_family=AF_INET; 
  646. daddr.sin_port=htons(80);
  648. CString str1 ;
  650. thisClass->m_lip->GetWindowText(str1);
  652. char lip[40];
  654. wcstombs(lip , str1.GetBuffer() , 39 );
  657. daddr.sin_addr.s_addr=inet_addr(lip); 
  658. int error = connect(m_serverSocket,(struct sockaddr *)&daddr,sizeof(daddr)); 
  659. const char * buf = "GET /MJPEG.CGI HTTP/1.0rnrn";
  662. fd_set fdRead; /* Read concourse define. */
  663. int ret; /* Return value. */
  664. TIMEVAL aTime; /* Event wait time define. */
  666. char recvBuf[RECV_BUF_SIZE];
  667. int allcount = 0;
  669. aTime.tv_sec = 1;
  670. aTime.tv_usec = 0;
  672. int recvLen;
  674. int f_recv = F_RECEIVE_NOWORKL;
  676. send( m_serverSocket,buf,100,0);
  678. TRACE(__T("Left Socket ok.rn"));
  679. while (thisClass->m_ThreadExit == FALSE)
  680. {
  681. if (thisClass->m_LeftReceived == TRUE)
  682. {
  683. TRACE(__T("Left Wait for Processing.rn"));
  684. Sleep(10);
  685. continue;
  686. }
  687. TRACE(__T("Left Receiving.rn"));
  688. /* Set empty to the fdRead Event. */
  689. FD_ZERO(&fdRead);
  691. /* Set read event to the client socket. */
  692. FD_SET(m_serverSocket,&fdRead);
  694. /* To judge whether there is any read event. */
  695. ret = select(0,&fdRead,NULL,NULL,&aTime);
  696. if (ret > 0)
  697. {
  699. if (FD_ISSET(m_serverSocket,&fdRead))
  700. {
  701. /* read event happen */
  702. recvLen = 0;
  704. /* recieve data */
  705. memset( recvBuf , 0 , RECV_BUF_SIZE );
  706. recvLen = recv( m_serverSocket , recvBuf , RECV_BUF_SIZE , 0 );
  708. if( recvLen <= 0 )
  709. {
  710. TRACE( _T( "Left TCP recive nothing.rn" ) );
  711. continue;
  712. }
  714. if( F_RECEIVE_NOWORKL == f_recv )
  715. {
  716. int tempcount;
  717. for( tempcount = 0 ; tempcount < recvLen - 1 ; tempcount++ )
  718. {
  719. if( ( recvBuf[tempcount] == (char)0xFF ) && ( recvBuf[tempcount + 1] == (char)0xD8 ) )
  720. {
  721. f_recv = F_RECEIVE_BEGINL;
  722. break;
  723. }                        
  724. }
  726. if(  F_RECEIVE_BEGINL == f_recv )
  727. {
  728. f_recv = F_RECEIVEL;
  729. thisClass->recvBytePointerL = 0;
  730. memcpy( thisClass->recvImageBufL , recvBuf + tempcount , recvLen - tempcount );
  731. thisClass->recvBytePointerL = recvLen - tempcount;
  732. }
  733. }
  734. else if( F_RECEIVEL == f_recv )
  735. {
  736. int tempcount;
  737. for( tempcount = 0 ; tempcount < recvLen  ; tempcount++ )
  738. {
  739. if( ( recvBuf[tempcount - 2] == (char)0xFF ) && ( recvBuf[tempcount - 1] == (char)0xD9 ) )
  740. {
  741. f_recv = F_RECEIVE_OVER_L;
  742. break;
  743. }
  744. }
  746. if( F_RECEIVEL == f_recv )   /* 未接收完一个文件 */
  747. {
  748. memcpy( thisClass->recvImageBufL + thisClass->recvBytePointerL , recvBuf , recvLen );
  749. thisClass->recvBytePointerL += recvLen;
  750. }
  751. else if( F_RECEIVE_OVER_L == f_recv ) /* 接收完一个文件 */
  752. {           
  755. memcpy( thisClass->recvImageBufL + thisClass->recvBytePointerL , recvBuf , tempcount );
  756. thisClass->recvBytePointerL += tempcount;
  758. CString strL;
  760. strL.Format( __T("D:\project\pic\002.jpg") , 1 );
  762. TRACE(__T("Left Received file.rn"));
  763. CFile ka;
  764. if( ka.Open( strL , CFile::modeCreate | CFile::modeReadWrite ) == TRUE )
  765. {
  766. TRACE(__T("Left Writting file.rn"));
  767. ka.SeekToBegin();
  768. ka.Write( thisClass->recvImageBufL , thisClass->recvBytePointerL );
  769. ka.Close();
  770. thisClass->m_LeftReceived = TRUE;
  771. }
  772. TRACE(__T("Left Received done.rn"));
  774. if( thisClass->f_MutexImageBufL == MUTEX_NONUSE )
  775. {
  776. thisClass->f_MutexImageBufL = MUTEX_USE;
  777. memcpy(thisClass->imageBufL.buf , thisClass->recvImageBufL , thisClass->recvBytePointerL );
  780. thisClass->imageBufL.size = thisClass->recvBytePointerL;
  781. thisClass->f_MutexImageBufL = MUTEX_NONUSE;
  782. }
  784. f_recv = F_RECEIVE_NOWORKL;
  786. for( ; tempcount < recvLen - 1 ; tempcount++ )
  787. {
  788. if( ( recvBuf[tempcount] == (char)0xFF ) && ( recvBuf[tempcount + 1] == (char)0xD8 ) )
  789. {
  790. f_recv = F_RECEIVE_BEGINL;
  791. break;
  792. }                        
  793. }
  795. if(  F_RECEIVE_BEGINL == f_recv )
  796. {
  797. f_recv = F_RECEIVEL;
  798. thisClass->recvBytePointerL = 0;
  799. memcpy( thisClass->recvImageBufL , recvBuf + tempcount , recvLen - tempcount );
  800. thisClass->recvBytePointerL = recvLen - tempcount;
  801. }
  803. }
  804. }
  805. }
  806. }
  808. }
  811. closesocket(m_serverSocket);
  812. WSACleanup();
  814. return TRUE;
  815. }
  817. //UINT ThreadL( LPVOID p)
  818. //{
  819. // WSADATA wsa;
  820. // /* initialize socket  */
  821. // WSAStartup(MAKEWORD(1,1),&wsa);
  822. // Ctest2eyesDlg * thisClass = (Ctest2eyesDlg*)p;
  823. //
  824. // SOCKET m_serverSocket;
  825. //
  826. // /* initialize socket  */
  827. //
  828. // /* create socket  */
  829. // m_serverSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  830. //
  831. // SOCKADDR_IN  serverAddr;
  832. // ZeroMemory((char *)&serverAddr,sizeof(serverAddr));
  833. // serverAddr.sin_family = AF_INET;
  834. // serverAddr.sin_port = htons(5565);
  835. // serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
  836. //
  837. // /* bind socket  */
  838. // bind(m_serverSocket, (struct sockaddr *)&serverAddr, sizeof(serverAddr));
  839. //
  840. // struct sockaddr_in daddr; 
  841. // memset((void *)&daddr,0,sizeof(daddr)); 
  842. // daddr.sin_family=AF_INET; 
  843. // daddr.sin_port=htons(80);
  844. //
  845. //
  846. // CString str1 ;
  847. //
  848. // thisClass->m_lip->GetWindowText(str1);
  849. //
  850. // char lip[40];
  851. //
  852. // wcstombs(lip , str1.GetBuffer() , 39 );
  853. //
  854. // daddr.sin_addr.s_addr=inet_addr(lip); 
  855. // int error = connect(m_serverSocket,(struct sockaddr *)&daddr,sizeof(daddr)); 
  856. // const char * buf = "GET /MJPEG.CGI HTTP/1.0rnrn";
  857. //
  858. //
  859. // fd_set fdRead; /* Read concourse define. */
  860. // int ret; /* Return value. */
  861. // TIMEVAL aTime; /* Event wait time define. */
  862. //
  863. // char recvBuf[RECV_BUF_SIZE];
  864. // int allcount = 0;
  865. //
  866. // aTime.tv_sec = 1;
  867. // aTime.tv_usec = 0;
  868. //
  869. // int recvLen;
  870. //
  871. // int f_recv = F_RECEIVE_NOWORKL;
  872. //
  873. // send( m_serverSocket,buf,100,0);
  874. //
  875. // TRACE(__T("Left Socket ok.rn"));
  876. // while (thisClass->m_ThreadExit == FALSE)
  877. // {
  878. //
  879. // if (thisClass->m_LeftReceived == TRUE)
  880. // {
  881. // //Sleep(10);
  882. // //continue;
  883. // }
  884. // /* Set empty to the fdRead Event. */
  885. // FD_ZERO(&fdRead);
  886. //
  887. // /* Set read event to the client socket. */
  888. // FD_SET(m_serverSocket,&fdRead);
  889. //
  890. // /* To judge whether there is any read event. */
  891. // ret = select(0,&fdRead,NULL,NULL,&aTime);
  892. // if (ret > 0)
  893. // {
  894. //
  895. // if (FD_ISSET(m_serverSocket,&fdRead))
  896. // {
  897. // /* read event happen */
  898. // recvLen = 0;
  899. //
  900. // /* recieve data */
  901. // memset( recvBuf , 0 , RECV_BUF_SIZE );
  902. // recvLen = recv( m_serverSocket , recvBuf , RECV_BUF_SIZE , 0 );
  903. //
  904. // if( recvLen <= 0 )
  905. // {
  906. // TRACE( _T( "TCP recive nothing ln" ) );
  907. // continue;
  908. // }
  909. //
  910. // if( F_RECEIVE_NOWORKL == f_recv )
  911. // {
  912. // int tempcount;
  913. // for( tempcount = 0 ; tempcount < recvLen - 1 ; tempcount++ )
  914. // {
  915. // if( ( recvBuf[tempcount] == (char)0xFF ) && ( recvBuf[tempcount + 1] == (char)0xD8 ) )
  916. // {
  917. // f_recv = F_RECEIVE_BEGINL;
  918. // break;
  919. // }                        
  920. // }
  921. //
  922. // if(  F_RECEIVE_BEGINL == f_recv )
  923. // {
  924. // f_recv = F_RECEIVEL;
  925. // thisClass->recvBytePointerL = 0;
  926. // memcpy( thisClass->recvImageBufL , recvBuf + tempcount , recvLen - tempcount );
  927. // thisClass->recvBytePointerL = recvLen - tempcount;
  928. // }
  929. // }
  930. // else if( F_RECEIVEL == f_recv )
  931. // {
  932. // int tempcount;
  933. // for( tempcount = 0 ; tempcount < recvLen  ; tempcount++ )
  934. // {
  935. // if( ( recvBuf[tempcount - 2] == (char)0xFF ) && ( recvBuf[tempcount - 1] == (char)0xD9 ) )
  936. // {
  937. // f_recv = F_RECEIVE_OVER_L;
  938. // break;
  939. // }
  940. // }
  941. //
  942. // if( F_RECEIVEL == f_recv )   /* 未接收完一个文件 */
  943. // {
  944. // memcpy( thisClass->recvImageBufL + thisClass->recvBytePointerL , recvBuf , recvLen );
  945. // thisClass->recvBytePointerL += recvLen;
  946. // }
  947. // else if( F_RECEIVE_OVER_L == f_recv ) /* 接收完一个文件 */
  948. // {                        
  949. // memcpy( thisClass->recvImageBufL + thisClass->recvBytePointerL , recvBuf , tempcount );
  950. // thisClass->recvBytePointerL += tempcount;
  951. //
  952. // CString strR;
  953. //
  954. // strR.Format( __T("D:\project\pic\002.jpg") , 1 );
  955. //
  956. // CFile ka;
  957. // if(  ka.Open( strR , CFile::modeCreate | CFile::modeReadWrite ) == TRUE )
  958. // {
  959. // ka.SeekToBegin();
  960. // ka.Write( thisClass->recvImageBufL , thisClass->recvBytePointerL );
  961. // ka.Close();
  962. // thisClass->m_LeftReceived = TRUE;
  963. // }
  964. //
  965. // if( thisClass->f_MutexImageBufL == MUTEX_NONUSE )
  966. // {
  967. // thisClass->f_MutexImageBufL = MUTEX_USE;
  968. // memcpy(thisClass->imageBufL.buf , thisClass->recvImageBufL , thisClass->recvBytePointerL );
  969. //
  970. //
  971. // thisClass->imageBufL.size = thisClass->recvBytePointerL;
  972. // thisClass->f_MutexImageBufL = MUTEX_NONUSE;
  973. // }
  974. //
  975. // f_recv = F_RECEIVE_NOWORKL;
  976. //
  977. // for( ; tempcount < recvLen - 1 ; tempcount++ )
  978. // {
  979. // if( ( recvBuf[tempcount] == (char)0xFF ) && ( recvBuf[tempcount + 1] == (char)0xD8 ) )
  980. // {
  981. // f_recv = F_RECEIVE_BEGINL;
  982. // break;
  983. // }                        
  984. // }
  985. //
  986. // if(  F_RECEIVE_BEGINL == f_recv )
  987. // {
  988. // f_recv = F_RECEIVEL;
  989. // thisClass->recvBytePointerL = 0;
  990. // memcpy( thisClass->recvImageBufL , recvBuf + tempcount , recvLen - tempcount );
  991. // thisClass->recvBytePointerL = recvLen - tempcount;
  992. // }
  993. //
  994. // }
  995. // }
  996. // }
  997. // }
  998. // }
  999. //
  1000. //
  1001. // closesocket(m_serverSocket);
  1002. // WSACleanup();
  1003. //
  1004. // return TRUE;
  1005. //}
  1006. //
  1007. //
  1009. void Ctest2eyesDlg::OnBnClickedButton1()
  1010. {
  1011. }
  1014. void Ctest2eyesDlg::OnTimer(UINT_PTR nIDEvent)
  1015. {
  1016. // TODO: 在此添加消息处理程序代码和/或调用默认值
  1018. switch(nIDEvent)
  1019. {
  1020. case MYTIMER:
  1021. {
  1022.   if (m_LeftReceived == TRUE && m_RightReceived == TRUE)
  1023.   {
  1024.   if (m_processing == FALSE)
  1025.   {
  1026. test_SIFT();
  1027.   }
  1028.   }
  1029. }
  1030. break;
  1031. default:
  1032. KillTimer(MYTIMER);
  1033. break;
  1034. }
  1037. CDialog::OnTimer(nIDEvent);
  1038. }
  1041. HBRUSH Ctest2eyesDlg::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)
  1042. {
  1043. HBRUSH hbr = CDialog::OnCtlColor(pDC, pWnd, nCtlColor);
  1045. switch(nCtlColor)   
  1046. {   
  1047. case   CTLCOLOR_STATIC:
  1048. switch(pWnd->GetDlgCtrlID())
  1049. {
  1050. case IDC_STATIC_ICON:
  1051. {
  1052. return m_BMPDisplayBrush;
  1053. }
  1054. break;
  1055. }
  1056. }
  1058. return hbr;
  1059. }
  1061. void Ctest2eyesDlg::OnBnClickedCancel()
  1062. {
  1063. // TODO: 在此添加控件通知处理程序代码
  1065. m_ThreadExit = TRUE;
  1066. exit(1);
  1067. OnCancel();
  1068. }