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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图象 > 查看源码
ED256View.cpp
资源名称：jiancesuanfa.rar　[点击查看]
上传用户：dfwb928
上传日期：2013-04-20
资源大小：228k
文件大小：16k
源码类别：

图形图象

开发平台：

Visual C++

ED256View.cpp：源码内容
  1. //////////////////////////////////////////////////////////////////
  2. // CED256View class (17/10/2000)
  3. // Author: James Matthews
  4. //
  5. // Implements a simple edge detection algorithm and 
  6. // prototyping system.
  7. //
  8. // Written for Generation5 (http://www.generation5.org/)
  9. //
  10. // See http://www.generation5.org/vision.shtml
  11. //     http://www.generation5.org/edgedetect.shtml for details.
  12. //
  14. #include "stdafx.h"
  15. #include "ED256.h"
  17. #include "ED256Doc.h"
  18. #include "ED256View.h"
  19. #include "Mainfrm.h"
  21. #include <math.h>
  22. #include <memory.h>
  24. #include "FilterDlg.h"
  26. #ifdef _DEBUG
  27. #define new DEBUG_NEW
  28. #undef THIS_FILE
  29. static char THIS_FILE[] = __FILE__;
  30. #endif
  32. /////////////////////////////////////////////////////////////////////////////
  33. // CED256View
  35. IMPLEMENT_DYNCREATE(CED256View, CView)
  37. BEGIN_MESSAGE_MAP(CED256View, CView)
  38. //{{AFX_MSG_MAP(CED256View)
  39. ON_COMMAND(ID_EDIT_EDGEDETECT, OnEditEdgeDetect)
  40. ON_COMMAND(ID_COLOURTYPE, OnColourType)
  41. ON_COMMAND(ID_FORMULA, OnFormula)
  42. ON_COMMAND(ID_EDIT_FORMULATYPE_DIFFERENCEAND, OnEditFormulatypeDifferenceand)
  43. ON_COMMAND(ID_EDIT_FORMULATYPE_DIFFERENCEOR, OnEditFormulatypeDifferenceor)
  44. ON_COMMAND(ID_EDIT_FORMULATYPE_SUMMATION, OnEditFormulatypeSummation)
  45. ON_COMMAND(ID_INVERSE, OnInverse)
  46. ON_COMMAND(ID_FILTER, OnFilter)
  47. ON_UPDATE_COMMAND_UI(ID_COLOURTYPE, OnUpdateColourtype)
  48. ON_UPDATE_COMMAND_UI(ID_INVERSE, OnUpdateInverse)
  49. ON_COMMAND(ID_EDIT_OUTPUT_BLACKANDWHITE, OnEditOutputBlackandwhite)
  50. ON_COMMAND(ID_EDIT_OUTPUT_COLOUR, OnEditOutputColour)
  51. ON_UPDATE_COMMAND_UI(ID_EDIT_OUTPUT_BLACKANDWHITE, OnUpdateEditOutputBlackandwhite)
  52. ON_UPDATE_COMMAND_UI(ID_EDIT_OUTPUT_COLOUR, OnUpdateEditOutputColour)
  53. ON_UPDATE_COMMAND_UI(ID_EDIT_FORMULATYPE_DIFFERENCEAND, OnUpdateEditFormulatypeDifferenceand)
  54. ON_UPDATE_COMMAND_UI(ID_EDIT_FORMULATYPE_DIFFERENCEOR, OnUpdateEditFormulatypeDifferenceor)
  55. ON_UPDATE_COMMAND_UI(ID_EDIT_FORMULATYPE_SUMMATION, OnUpdateEditFormulatypeSummation)
  56. ON_WM_ERASEBKGND()
  57. ON_COMMAND(ID_EDIT_PROTOTYPING, OnEditPrototyping)
  58. ON_COMMAND(ID_CHANGERESOLUTION, OnChangeResolution)
  59. ON_COMMAND(ID_EDIT_COPY, OnEditCopy)
  60. ON_UPDATE_COMMAND_UI(ID_RES_LOW, OnUpdateResLow)
  61. ON_UPDATE_COMMAND_UI(ID_RES_MEDIUM, OnUpdateResMedium)
  62. ON_UPDATE_COMMAND_UI(ID_RES_HIGH, OnUpdateResHigh)
  63. //}}AFX_MSG_MAP
  64. ON_COMMAND_RANGE(ID_RES_LOW, ID_RES_HIGH, OnResolution)
  65. END_MESSAGE_MAP()
  67. /////////////////////////////////////////////////////////////////////////////
  68. // CED256View construction/destruction
  70. CED256View::CED256View() {
  71. m_iFormula = 0;
  72. m_iResolution = 4;
  73. m_bColour = true;
  74. m_bInverse = false;
  76. m_crPlot = RGB(0,0,0);
  77. m_crNoPlot = RGB(255,255,255);
  79. m_fFilter[0] = 1/6.0f;
  80. m_fFilter[1] = 2/3.0f;
  81. m_fFilter[2] = 1/6.0f;
  82. m_fFilter[3] = 2/3.0f;
  83. m_fFilter[4] = -10/3.0f;
  84. m_fFilter[5] = 2/3.0f;
  85. m_fFilter[6] = 1/6.0f;
  86. m_fFilter[7] = 2/3.0f;
  87. m_fFilter[8] = 1/6.0f;
  89. m_crProtoColours[0] = RGB(255,0,0);
  90. m_crProtoColours[1] = RGB(128,0,0);
  91. m_crProtoColours[2] = RGB(0,255,0);
  92. m_crProtoColours[3] = RGB(0,128,0);
  93. m_crProtoColours[4] = RGB(0,0,255);
  94. m_crProtoColours[5] = RGB(0,0,128);
  95. m_crProtoColours[6] = RGB(255,0,255);
  96. m_crProtoColours[7] = RGB(128,0,128);
  97. m_crProtoColours[8] = RGB(0,0,0);
  98. m_crProtoColours[9] = RGB(255,255,255);
  99. }
  101. CED256View::~CED256View() {}
  103. BOOL CED256View::PreCreateWindow(CREATESTRUCT& cs) {
  104. return CView::PreCreateWindow(cs);
  105. }
  107. /////////////////////////////////////////////////////////////////////////////
  108. // CED256View drawing
  110. void CED256View::OnDraw(CDC* pDC) {
  111. CED256Doc* pDoc = GetDocument();
  112. ASSERT_VALID(pDoc);
  114. CRect rect;
  115. GetClientRect(&rect);
  117. CDC dc;
  118. CBitmap bmp, *oldbmp;
  119. dc.CreateCompatibleDC(pDC);
  120. bmp.CreateCompatibleBitmap(pDC, rect.Width(), rect.Height());
  121. oldbmp = dc.SelectObject(&bmp);
  123. dc.FillSolidRect(rect, RGB(255,255,255));
  125. int cxDIB = 0, cyDIB = 0;
  126. HDIB hDIB = pDoc->GetHDIB();
  127. if (hDIB) {
  128. LPSTR lpDIB = (LPSTR) ::GlobalLock((HGLOBAL) hDIB);
  129. cxDIB = (int) ::DIBWidth(lpDIB);
  130. cyDIB = (int) ::DIBHeight(lpDIB);
  131. ::GlobalUnlock((HGLOBAL) hDIB);
  132. CRect rcDIB;
  133. rcDIB.top = rcDIB.left = 0;
  134. rcDIB.right = cxDIB;
  135. rcDIB.bottom = cyDIB;
  136. CRect rcDest = rcDIB;
  138. if (cxDIB * 2 <= rect.Width() || !(HBITMAP(m_bmpEdges))) {
  139. ::PaintDIB(dc.m_hDC, &rcDest, hDIB,
  140. &rcDIB, pDoc->GetDocPalette());
  141. }
  142. }
  144. if ((HBITMAP)(m_bmpEdges)) {
  145. CDC cdc;
  146. CBitmap *oldbmp;
  148. cdc.CreateCompatibleDC(pDC);
  149. oldbmp = cdc.SelectObject(&m_bmpEdges);
  151. if (cxDIB * 2 < rect.Width()) {
  152. dc.BitBlt(cxDIB+1,0,cxDIB,cyDIB+m_iOffset,&cdc,0,0,SRCCOPY);
  153. } else {
  154. dc.BitBlt(0,0,cxDIB,cyDIB+m_iOffset,&cdc,0,0,SRCCOPY);
  155. }
  156. }
  158. pDC->BitBlt(0,0,rect.Width(),rect.Height(),&dc,0,0,SRCCOPY);
  159. dc.SelectObject(oldbmp);
  160. }
  162. /////////////////////////////////////////////////////////////////////////////
  163. // CED256View diagnostics
  165. #ifdef _DEBUG
  166. void CED256View::AssertValid() const {
  167. CView::AssertValid();
  168. }
  170. void CED256View::Dump(CDumpContext& dc) const {
  171. CView::Dump(dc);
  172. }
  174. CED256Doc* CED256View::GetDocument() {
  175. ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CED256Doc)));
  176. return (CED256Doc*)m_pDocument;
  177. }
  178. #endif //_DEBUG
  180. /////////////////////////////////////////////////////////////////////////////
  181. // CED256View message handlers
  183. void CED256View::OnEditEdgeDetect() {
  184. CWaitCursor wait;
  186. CMainFrame* pMfm = STATIC_DOWNCAST(CMainFrame, AfxGetMainWnd());
  188. m_iOffset = 0;
  189. int thresh = pMfm->m_iThreshold;
  191. CDC sc1,sc2; 
  192. CClientDC dc(this);
  194. sc1.CreateCompatibleDC(&dc);
  195. sc2.CreateCompatibleDC(&dc);
  197. CBitmap *src1old, bmsrc, *src2old;
  199. int cxDIB, cyDIB;
  201. CED256Doc* pDoc = GetDocument();
  202. HDIB hDIB = pDoc->GetHDIB();
  204. GetDIBSize(cxDIB, cyDIB);
  206. if ((HBITMAP)(m_bmpEdges)) m_bmpEdges.Detach();
  208. bmsrc.CreateCompatibleBitmap(&dc, cxDIB, cyDIB);
  209. m_bmpEdges.CreateCompatibleBitmap(&dc, cxDIB, cyDIB);
  210.    
  211. src1old = sc1.SelectObject(&bmsrc);
  212. src2old = sc2.SelectObject(&m_bmpEdges);
  214. ::PaintDIB(sc1.m_hDC, &CRect(0,0,cxDIB,cyDIB), hDIB,
  215. &CRect(0,0,cxDIB,cyDIB), pDoc->GetDocPalette());
  217. float red, blue, green;
  218. // int red, blue, green;
  219. for (int i=1;i<cxDIB-1;i++) {
  220. for (int j=1;j<cyDIB-1;j++) {
  221. red = blue = green = 0;
  223. UpdateTotals(red, blue, green, m_fFilter[4], sc1.GetPixel(i,j));
  225. UpdateTotals(red, blue, green, m_fFilter[0], sc1.GetPixel(i-1,j));
  226. UpdateTotals(red, blue, green, m_fFilter[2], sc1.GetPixel(i+1,j));
  227. UpdateTotals(red, blue, green, m_fFilter[6], sc1.GetPixel(i,j-1));
  228. UpdateTotals(red, blue, green, m_fFilter[8], sc1.GetPixel(i,j+1));
  230. UpdateTotals(red, blue, green, m_fFilter[1], sc1.GetPixel(i-1,j-1));
  231. UpdateTotals(red, blue, green, m_fFilter[3], sc1.GetPixel(i+1,j-1));
  232. UpdateTotals(red, blue, green, m_fFilter[5], sc1.GetPixel(i-1,j+1));
  233. UpdateTotals(red, blue, green, m_fFilter[7], sc1.GetPixel(i+1,j+1));
  235. // Get the threshold value, and check whether any of the
  236. // values exceed the threshold value.
  237. if (Plot(int(red),int(green),int(blue),thresh)) {
  238. if (m_bColour)
  239. sc2.SetPixel(i,j, RGB(int(red),int(blue),int(green)));
  240. else sc2.SetPixel(i,j, m_crPlot);
  241. } else {
  242. sc2.SetPixel(i,j, m_crNoPlot);
  243. }
  244. }
  246. pMfm->PercentComplete(i / float(cxDIB) * 100);
  247. }
  249. CBrush br(RGB(0,0,0));
  250. sc2.FrameRect(&CRect(0,0,cxDIB, cyDIB), &br);
  252. sc1.SelectObject(src1old);
  253. sc2.SelectObject(src2old);
  255. Invalidate();
  257. pMfm->SetStatusMessage(AFX_IDS_IDLEMESSAGE);
  258. }
  260. void CED256View::UpdateTotals(float &r, float &g, float &b, float filter, COLORREF cr) {
  261. r += GetRValue(cr)*filter;
  262. b += GetBValue(cr)*filter;
  263. g += GetGValue(cr)*filter;
  264. }
  266. void CED256View::OnColourType() {
  267. m_bColour = !m_bColour;
  268. }
  270. void CED256View::OnFormula() {
  271. CMainFrame* pMfm = STATIC_DOWNCAST(CMainFrame, AfxGetMainWnd());
  273. PullDownToolBar(pMfm->GetToolbar(), ID_FORMULA, IDR_FORMULA, m_iFormula);
  274. }
  276. void CED256View::PullDownToolBar(CToolBar *bar, UINT uButton, UINT uMenu, int bold) {
  277. // To be professional, get the index from the command ID.
  278. int ind = bar->CommandToIndex(uButton);
  280. if (ind == -1) return;
  282. CRect rect;
  283. bar->GetItemRect(ind,&rect);
  284. bar->ClientToScreen(&rect);
  286. CMenu menu;
  287. VERIFY(menu.LoadMenu(uMenu));
  288. CMenu* pPopup = menu.GetSubMenu(0);
  289. ASSERT(pPopup != NULL); 
  291. if (bold > -1) SetMenuDefaultItem(pPopup->m_hMenu, bold, true);
  293. pPopup->TrackPopupMenu(TPM_LEFTALIGN, rect.TopLeft().x, rect.BottomRight().y, this);
  294. }
  296. bool CED256View::Plot(int r, int g, int b, int t) {
  297. switch(m_iFormula) {
  298. case 0: return (r > t && g > t && b > t);
  299. case 1: return (r > t || g > t || b > t);
  300. case 2: return (r+g+b > t);
  301. }
  303.   return false;
  304. }
  306. void CED256View::OnEditFormulatypeDifferenceand() {
  307. m_iFormula = 0;
  308. }
  310. void CED256View::OnEditFormulatypeDifferenceor() {
  311. m_iFormula = 1;
  312. }
  314. void CED256View::OnEditFormulatypeSummation() {
  315. m_iFormula = 2;
  316. }
  318. void CED256View::OnInverse() {
  319. m_bInverse = !m_bInverse;
  321. if (!m_bInverse) {
  322. m_crPlot = RGB(0,0,0);
  323. m_crNoPlot = RGB(255,255,255);
  324. } else {
  325. m_crPlot = RGB(255,255,255);
  326. m_crNoPlot = RGB(0,0,0);
  327. }
  328. }
  330. void CED256View::OnFilter() {
  331. CFilterDlg dlg;
  333. dlg.SetFilter(&m_fFilter[0]);
  334. dlg.DoModal();
  336. m_fFilter[0] = dlg.m_fEdit1;
  337. m_fFilter[1] = dlg.m_fEdit2;
  338. m_fFilter[2] = dlg.m_fEdit3;
  339. m_fFilter[3] = dlg.m_fEdit4;
  340. m_fFilter[4] = dlg.m_fEdit5;
  341. m_fFilter[5] = dlg.m_fEdit6;
  342. m_fFilter[6] = dlg.m_fEdit7;
  343. m_fFilter[7] = dlg.m_fEdit8;
  344. m_fFilter[8] = dlg.m_fEdit9;
  345. }
  347. void CED256View::OnUpdateColourtype(CCmdUI* pCmdUI) {
  348. pCmdUI->SetCheck(m_bColour);
  349. }
  351. void CED256View::OnUpdateInverse(CCmdUI* pCmdUI) {
  352. pCmdUI->SetCheck(m_bInverse);
  353. }
  355. void CED256View::OnEditOutputBlackandwhite() {
  356. m_bColour = false;
  357. }
  359. void CED256View::OnEditOutputColour() {
  360. m_bColour = true;
  361. }
  363. void CED256View::OnInitialUpdate() {
  364. CView::OnInitialUpdate();
  366. if ((HBITMAP)(m_bmpEdges)) m_bmpEdges.Detach();
  367. }
  369. BOOL CED256View::OnEraseBkgnd(CDC* pDC) {
  370. return FALSE;
  371. }
  373. void CED256View::OnEditPrototyping() {
  374. CWaitCursor wait;
  376. CMainFrame* pMfm = STATIC_DOWNCAST(CMainFrame, AfxGetMainWnd());
  378. m_iOffset = 50;
  379. int thresh = pMfm->m_iThreshold;
  381. CDC sc1,sc2; 
  382. CClientDC dc(this);
  384. sc1.CreateCompatibleDC(&dc);
  385. sc2.CreateCompatibleDC(&dc);
  387. CBitmap *src1old, bmsrc, *src2old;
  389. int cxDIB, cyDIB; // The width/height of the bitmap
  391. CED256Doc* pDoc = GetDocument();
  392. HDIB hDIB = pDoc->GetHDIB();
  394. GetDIBSize(cxDIB, cyDIB);
  396. if ((HBITMAP)(m_bmpEdges)) m_bmpEdges.Detach();
  398. bmsrc.CreateCompatibleBitmap(&dc, cxDIB, cyDIB);
  399. m_bmpEdges.CreateCompatibleBitmap(&dc, cxDIB, cyDIB + 100);
  400.    
  401. src1old = sc1.SelectObject(&bmsrc);
  402. src2old = sc2.SelectObject(&m_bmpEdges);
  404. ::PaintDIB(sc1.m_hDC, &CRect(0,0,cxDIB,cyDIB), hDIB,
  405. &CRect(0,0,cxDIB,cyDIB), pDoc->GetDocPalette());
  407. ::PaintDIB(sc2.m_hDC, &CRect(0,0,cxDIB,cyDIB), hDIB,
  408. &CRect(0,0,cxDIB,cyDIB), pDoc->GetDocPalette());
  410. ////////////////////////////////////////////////
  411. // START PROTOTYPING
  413. _protoBmp samples[MAX_SAMPLES];
  414. _protoBmp prototypes[MAX_PROTOTYPES];
  416. int x,y;
  417. srand(unsigned(time(NULL)));
  419. pMfm->SetStatusMessage("Creating samples and prototypes...");
  421. // Initialize the samples
  422. for (int i=0;i<MAX_SAMPLES;i++) {
  423. x = rand() % cxDIB;
  424. y = rand() % cyDIB;
  426. for (int j=0;j<15;j++) {
  427. for (int k=0;k<15;k++) {
  428. samples[i].pixels[j][k] = char(sc1.GetPixel(x+j,y+k) & 0xFF);
  429. }
  430. }
  431. }
  433. // Initialize the prototypes
  434. for (i=0;i<MAX_PROTOTYPES;i++) {
  435. for (int j=0;j<15;j++) {
  436. for (int k=0;k<15;k++) {
  437. prototypes[i].pixels[j][k] = rand() % 255;
  438. }
  439. }
  440. }
  442. pMfm->SetStatusMessage("Competitive learning initialized...");
  444. int ind, k = 2, avg, bestavg, bestind, pavg[MAX_PROTOTYPES];
  445. for (i=0;i<MAX_PITERATIONS;i++) {
  446. memset(pavg,0,sizeof(avg));
  448. ind = rand() % MAX_SAMPLES;
  450. for (int j=0;j<MAX_PROTOTYPES;j++) {
  451. avg = 0;
  452. for (int k=0;k<15;k++) {
  453. for (int l=0;l<15;l++) {
  454. avg += abs(prototypes[j].pixels[k][l] - samples[ind].pixels[k][l]);
  455. }
  456. }
  458. pavg[j] = avg / (15*15);
  459. }
  461. bestind = 0; bestavg = pavg[0];
  462. for (j=1;j<MAX_PROTOTYPES;j++) {
  463. if (pavg[j] < bestavg) {
  464. bestind = j;
  465. bestavg = pavg[j];
  466. }
  467. }
  469. for (j=0;j<15;j++) {
  470. for (int k=0;k<15;k++) {
  471. prototypes[bestind].pixels[j][k] = 
  472. (prototypes[bestind].pixels[j][k] - samples[ind].pixels[j][k]) / 100 * k + samples[ind].pixels[j][k];
  473. }
  474. }
  475. }
  477. // Create the picture.
  478. _protoBmp test; 
  479. int minus = (m_iResolution/2);
  481. for (i=0;i<cxDIB+m_iResolution;i+=m_iResolution) {
  482. for (int j=0;j<cyDIB+m_iResolution;j+=m_iResolution) {
  483. // Get the pixels;
  484. for (int k=-7;k<8;k++) {
  485. for (int l=-7;l<8;l++) {
  486. test.pixels[k+7][l+7] = char(sc1.GetPixel(i+k,j+l) & 0xFF);
  487. }
  488. }
  490. for (int m=0;m<MAX_PROTOTYPES;m++) {
  491. avg = 0;
  492. for (int k=0;k<15;k++) {
  493. for (int l=0;l<15;l++) {
  494. avg += abs(prototypes[m].pixels[k][l] - test.pixels[k][l]);
  495. }
  496. }
  498. pavg[m] = avg / (15*15);
  499. }
  501. bestind = 0; bestavg = pavg[0];
  502. for (m=1;m<MAX_PROTOTYPES;m++) {
  503. if (pavg[m] < bestavg) {
  504. bestind = m;
  505. bestavg = pavg[m];
  506. }
  507. }
  509. sc2.FillSolidRect(i-minus,j-minus,m_iResolution,m_iResolution,m_crProtoColours[bestind]);
  510. }
  512. pMfm->PercentComplete(i/float(cxDIB)*100);
  513. }
  515. // Draw the prototypes and colours
  517. sc2.FillSolidRect(0,cyDIB,cxDIB,m_iOffset,RGB(255,255,255));
  519. for (i=0;i<MAX_PROTOTYPES;i++) {
  520. for (int j=0;j<15;j++) {
  521. for (int k=0;k<15;k++) {
  522. BYTE col = prototypes[i].pixels[j][k];
  523. sc2.SetPixel(j+(i*16),k+cyDIB+5,RGB(col,col,col));
  524. }
  525. }
  527. sc2.FillSolidRect(i*16,20+cyDIB+5,15,5,m_crProtoColours[i]);
  528. }
  530. CBrush br(RGB(0,0,0));
  531. sc2.FrameRect(&CRect(0,0,cxDIB, cyDIB), &br);
  533. sc1.SelectObject(src1old);
  534. sc2.SelectObject(src2old);
  536. Invalidate();
  538. pMfm->SetStatusMessage(AFX_IDS_IDLEMESSAGE);
  539. }
  541. void CED256View::OnChangeResolution() {
  542. int bold;
  543. switch (m_iResolution) {
  544. case 15: bold = 0; break;
  545. case 4:  bold = 1; break;
  546. case 1:  bold = 2; break;
  547. }
  549. CMainFrame* pMfm = STATIC_DOWNCAST(CMainFrame, AfxGetMainWnd());
  551. PullDownToolBar(&(pMfm->m_wndProtoBar), ID_CHANGERESOLUTION, IDR_RESOLUTION, bold);
  552. }
  554. void CED256View::OnResolution(UINT uID) {
  555. switch (uID) {
  556. case ID_RES_LOW: m_iResolution = 15; break;
  557. case ID_RES_MEDIUM: m_iResolution = 4; break;
  558. case ID_RES_HIGH: m_iResolution = 1; break;
  559. }
  560. }
  562. void CED256View::CopyBitmap() {
  563. CClientDC dc(this);
  564. CDC bmpdc, memdc;
  565. CBitmap bmp, *oldbmp1, *oldbmp2;
  567. int cxDIB, cyDIB; // The width/height of the bitmap
  569. GetDIBSize(cxDIB, cyDIB);
  571. bmpdc.CreateCompatibleDC(GetDC());
  572. memdc.CreateCompatibleDC(GetDC());
  573. bmp.CreateCompatibleBitmap(&dc, cxDIB, cyDIB);
  575. oldbmp1 = bmpdc.SelectObject(&m_bmpEdges);
  576. oldbmp2 = memdc.SelectObject(&bmp);
  578. CBrush br(RGB(0,0,0));
  579. memdc.BitBlt(0,0,cxDIB,cyDIB,&bmpdc,0,0,SRCCOPY);
  580. memdc.FrameRect(&CRect(0,0,cxDIB, cyDIB), &br);
  582. OpenClipboard();
  583. EmptyClipboard();
  584. SetClipboardData(CF_BITMAP, bmp.GetSafeHandle());
  585. CloseClipboard();
  587. bmp.Detach();
  588. bmpdc.SelectObject(oldbmp1);
  589. memdc.SelectObject(oldbmp2);
  590. }
  592. void CED256View::OnEditCopy() {
  593. CopyBitmap();
  594. }
  596. // FIXME: The DIB size really should be a class member!
  598. void CED256View::GetDIBSize(int &cx, int &cy) {
  599. CED256Doc* pDoc = GetDocument();
  600. HDIB hDIB = pDoc->GetHDIB();
  602. if (hDIB) {
  603. LPSTR lpDIB = (LPSTR) ::GlobalLock((HGLOBAL) hDIB);
  604. cx = (int) ::DIBWidth(lpDIB);
  605. cy = (int) ::DIBHeight(lpDIB);
  606. ::GlobalUnlock((HGLOBAL) hDIB);
  607. } else return;
  608. }
  610. // ON_COMMAND_UPDATE SCHTUFF
  612. void CED256View::OnUpdateEditOutputBlackandwhite(CCmdUI* pCmdUI) {
  613. pCmdUI->SetCheck(!m_bColour);
  614. }
  616. void CED256View::OnUpdateEditOutputColour(CCmdUI* pCmdUI) {
  617. pCmdUI->SetCheck(m_bColour);
  618. }
  620. void CED256View::OnUpdateEditFormulatypeDifferenceand(CCmdUI* pCmdUI) {
  621. pCmdUI->SetCheck(m_iFormula == 0);
  622. }
  624. void CED256View::OnUpdateEditFormulatypeDifferenceor(CCmdUI* pCmdUI) {
  625. pCmdUI->SetCheck(m_iFormula == 1);
  626. }
  628. void CED256View::OnUpdateEditFormulatypeSummation(CCmdUI* pCmdUI) {
  629. pCmdUI->SetCheck(m_iFormula == 2);
  630. }
  632. void CED256View::OnUpdateResLow(CCmdUI* pCmdUI) {
  633. pCmdUI->SetCheck(m_iResolution == 15);
  634. }
  636. void CED256View::OnUpdateResMedium(CCmdUI* pCmdUI) {
  637. pCmdUI->SetCheck(m_iResolution == 4);
  638. }
  640. void CED256View::OnUpdateResHigh(CCmdUI* pCmdUI) {
  641. pCmdUI->SetCheck(m_iResolution == 1);
  642. }