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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 视频捕捉/采集 > 查看源码
HandVu_Cintf.cpp
资源名称：handvu-beta3.tar.gz　[点击查看]
上传用户：lijia5631
上传日期：2008-11-10
资源大小：1214k
文件大小：17k
源码类别：

视频捕捉/采集

开发平台：

MultiPlatform

HandVu_Cintf.cpp：源码内容
  1. /**
  2.   * HandVu - a library for computer vision-based hand gesture
  3.   * recognition.
  4.   * Copyright (C) 2004 Mathias Kolsch, matz@cs.ucsb.edu
  5.   *
  6.   * This program is free software; you can redistribute it and/or
  7.   * modify it under the terms of the GNU General Public License
  8.   * as published by the Free Software Foundation; either version 2
  9.   * of the License, or (at your option) any later version.
  10.   *
  11.   * This program is distributed in the hope that it will be useful,
  12.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.   * GNU General Public License for more details.
  15.   *
  16.   * You should have received a copy of the GNU General Public License
  17.   * along with this program; if not, write to the Free Software
  18.   * Foundation, Inc., 59 Temple Place - Suite 330, 
  19.   * Boston, MA  02111-1307, USA.
  20.   *
  21.   * $Id: HandVu_Cintf.cpp,v 1.3 2005/10/30 23:00:43 matz Exp $
  22. **/
  24. // HandVu_Cintf.cpp: C interface to the C++ classes in HandVu.cpp
  25. //
  27. #include "Common.h"
  28. #include "HandVu.hpp"
  29. #include "HandVu.h"
  30. #include "GestureServer.h"
  33. #if defined(WIN32)
  35. #if defined(GetMessage)
  36. #undef GetMessage
  37. #endif
  39. #include <time.h>
  40. #define CLOCKS_PER_USEC ((double)(CLOCKS_PER_SEC)/1000000.0)
  41. class RefClockWindows : public RefClock {
  42. public:
  43.   virtual RefTime GetCurrentTimeUsec() const;
  44. };
  45. RefTime RefClockWindows::GetCurrentTimeUsec() const
  46. {
  47.   clock_t ct = clock();
  48.   return (RefTime) (ct/CLOCKS_PER_USEC);
  49. }
  50. #define RefClockArch RefClockWindows
  52. #else //WIN32
  54. #define CLOCKS_PER_USEC ((double)(CLOCKS_PER_SEC)/1000000.0)
  55. class RefClockLinux : public RefClock {
  56. public:
  57.   virtual RefTime GetCurrentTimeUsec() const;
  58. };
  59. RefTime RefClockLinux::GetCurrentTimeUsec() const
  60. {
  61.   clock_t ct = clock();
  62.   return (RefTime) (ct/CLOCKS_PER_USEC);
  63. }
  64. #define RefClockArch RefClockLinux
  66. #endif //WIN32
  69. class DisplayCallbackCintf : public DisplayCallback {
  70.  public:
  71.   DisplayCallbackCintf(void (*cb)(IplImage* img, hvAction action)) :
  72.     m_cb(cb) {}
  73.   virtual void Display(IplImage* img, HandVu::HVAction action);
  74.  protected:
  75.   void (*m_cb)(IplImage*, hvAction);
  76. };
  77. void DisplayCallbackCintf::Display(IplImage* img, HandVu::HVAction action)
  78. {
  79.   CV_FUNCNAME( "hvDisplayCallback" ); // declare cvFuncName
  80.   __BEGIN__;
  81.   hvAction act;
  82.   switch (action) {
  83.   case HandVu::HV_INVALID_ACTION:
  84.     act = HV_INVALID_ACTION; break;
  85.   case HandVu::HV_PROCESS_FRAME:
  86.     act = HV_PROCESS_FRAME; break;
  87.   case HandVu::HV_SKIP_FRAME:
  88.     act = HV_SKIP_FRAME; break;
  89.   case HandVu::HV_DROP_FRAME:
  90.     act = HV_DROP_FRAME; break;
  91.   default:
  92.     CV_ERROR(CV_StsError, "unknown HVAction code");
  93.   }  
  94.   m_cb(img, act);
  95.   __END__;
  96. }
  99. typedef GestureServer* GestureServerPtr;
  100. vector<GestureServerPtr> g_pservers;
  101. HandVu* g_pHandVu = NULL;
  102. RefClockArch* g_pClock = NULL;
  103. DisplayCallbackCintf* g_displayCallback = NULL;
  105. void hvInitialize(int image_width, int image_height)
  106. {
  107.   CV_FUNCNAME( "hvInitialize" ); // declare cvFuncName
  108.   __BEGIN__;
  109.   if (image_width<0 || image_height<0) {
  110.     CV_ERROR(CV_BadImageSize, "negative image width or height");
  111.   }
  112.   if (g_pHandVu) {
  113.     CV_ERROR(CV_StsError, "HandVu already initialized");
  114.   }
  115.   try {
  116.     g_pHandVu = new HandVu();
  117.     g_pClock = new RefClockArch();
  118.     g_pHandVu->Initialize(image_width, image_height, g_pClock, NULL);
  119.   } catch (HVException& hve) {
  120.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  121.   }
  122.   __END__;
  123. }
  125. void hvUninitialize()
  126. {
  127.   CV_FUNCNAME( "hvUninitialize" ); // declare cvFuncName
  128.   __BEGIN__;
  129.   if (!g_pHandVu) {
  130.     CV_ERROR(CV_StsError, "HandVu not initialized");
  131.   }
  132.   try {
  133.     g_pHandVu->~HandVu();
  134.     g_pHandVu = NULL;
  135.     delete g_pClock;
  136.     g_pClock = NULL;
  137.     if (g_displayCallback) {
  138.       delete g_displayCallback;
  139.     }
  141.     // gesture servers
  142.     for (int i=0; i<(int)g_pservers.size(); i++) delete g_pservers[i];
  143.     g_pservers.clear();
  145.   } catch (HVException& hve) {
  146.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  147.   }
  148.   __END__;
  149. }
  151. void hvLoadConductor(const string& filename)
  152. {
  153.   CV_FUNCNAME( "hvLoadConductor" ); // declare cvFuncName
  154.   __BEGIN__;
  155.   if (!g_pHandVu) {
  156.     CV_ERROR(CV_StsError, "HandVu not initialized");
  157.   }
  158.   try {
  159.     g_pHandVu->LoadConductor(filename);
  160.   } catch (HVException& hve) {
  161.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  162.   }
  163.   __END__;
  164. }
  166. bool hvConductorLoaded()
  167. {
  168.   CV_FUNCNAME( "hvConductorLoaded" ); // declare cvFuncName
  169.   __BEGIN__;
  170.   if (!g_pHandVu) {
  171.     CV_ERROR(CV_StsError, "HandVu not initialized");
  172.   }
  173.   try {
  174.     return g_pHandVu->ConductorLoaded();
  175.   } catch (HVException& hve) {
  176.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  177.   }
  178.   __END__;
  179. }
  182. void hvStartRecognition(int obj_id)
  183. {
  184.   CV_FUNCNAME( "hvStartRecognition" ); // declare cvFuncName
  185.   __BEGIN__;
  186.   if (!g_pHandVu) {
  187.     CV_ERROR(CV_StsError, "HandVu not initialized");
  188.   }
  189.   try {
  190.     g_pHandVu->StartRecognition(obj_id);
  191.   } catch (HVException& hve) {
  192.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  193.   }
  194.   __END__;
  195. }
  197. void hvStopRecognition(int obj_id)
  198. {
  199.   CV_FUNCNAME( "hvStopRecognition" ); // declare cvFuncName
  200.   __BEGIN__;
  201.   if (!g_pHandVu) {
  202.     CV_ERROR(CV_StsError, "HandVu not initialized");
  203.   }
  204.   try {
  205.     g_pHandVu->StopRecognition(obj_id);
  206.   } catch (HVException& hve) {
  207.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  208.   }
  209.   __END__;
  210. }
  212. hvAction hvProcessFrame(IplImage* inOutImage, IplImage* rightImage)
  213. {
  214.   CV_FUNCNAME( "hvProcessFrame" ); // declare cvFuncName
  215.   __BEGIN__;
  216.   if (!g_pHandVu) {
  217.     CV_ERROR(CV_StsError, "HandVu not initialized");
  218.   }
  219.   try {
  220.     RefTime t = g_pClock->GetCurrentTimeUsec();
  221.     GrabbedImage gi(inOutImage, t, -1);
  222.     HandVu::HVAction action = g_pHandVu->ProcessFrame(gi, rightImage);
  223.     switch (action) {
  224.       case HandVu::HV_INVALID_ACTION:
  225.         return HV_INVALID_ACTION;
  226.       case HandVu::HV_PROCESS_FRAME:
  227.         return HV_PROCESS_FRAME;
  228.       case HandVu::HV_SKIP_FRAME:
  229.         return HV_SKIP_FRAME;
  230.       case HandVu::HV_DROP_FRAME:
  231.         return HV_DROP_FRAME;
  232.       default:
  233.         CV_ERROR(CV_StsError, "unknown HandVu::HVAction");
  234.     }
  236.   } catch (HVException& hve) {
  237.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  238.   }
  239.   __END__;
  240. }
  242. bool hvIsActive()
  243. {
  244.   CV_FUNCNAME( "hvIsActive" ); // declare cvFuncName
  245.   __BEGIN__;
  246.   if (!g_pHandVu) {
  247.     CV_ERROR(CV_StsError, "HandVu not initialized");
  248.   }
  249.   try {
  250.     bool active = g_pHandVu->IsActive();
  251.     return active;
  252.   } catch (HVException& hve) {
  253.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  254.   }
  255.   __END__;
  256. }
  258. void hvAsyncSetup(int num_buffers, void (*cb)(IplImage* img, hvAction action))
  259. {
  260.   CV_FUNCNAME( "hvAsyncSetup" ); // declare cvFuncName
  261.   __BEGIN__;
  262.   if (!g_pHandVu) {
  263.     CV_ERROR(CV_StsError, "HandVu not initialized");
  264.   }
  265.   try {
  266.     if (g_displayCallback) {
  267.       delete g_displayCallback;
  268.     }
  269.     g_displayCallback = new DisplayCallbackCintf(cb);
  270.     g_pHandVu->AsyncSetup(num_buffers, g_displayCallback);
  271.     
  272.   } catch (HVException& hve) {
  273.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  274.   }
  275.   __END__;
  276. }
  278. void hvAsyncGetImageBuffer(IplImage** pImage, int* pBufferID)
  279. {
  280.   CV_FUNCNAME( "hvAsyncGetImageBuffer" ); // declare cvFuncName
  281.   __BEGIN__;
  282.   if (!g_pHandVu) {
  283.     CV_ERROR(CV_StsError, "HandVu not initialized");
  284.   }
  285.   try {
  286.     g_pHandVu->AsyncGetImageBuffer(pImage, pBufferID);
  287.   } catch (HVException& hve) {
  288.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  289.   }
  290.   __END__;
  291. }
  293. void hvAsyncProcessFrame(int bufferID)
  294. {
  295.   CV_FUNCNAME( "hvAsyncProcessFrame" ); // declare cvFuncName
  296.   __BEGIN__;
  297.   if (!g_pHandVu) {
  298.     CV_ERROR(CV_StsError, "HandVu not initialized");
  299.   }
  300.   try {
  301.     RefTime t = g_pClock->GetCurrentTimeUsec();
  302.     g_pHandVu->AsyncProcessFrame(bufferID, t);
  303.   } catch (HVException& hve) {
  304.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  305.   }
  306.   __END__;
  307. }
  310. void hvGetState(int obj_id, hvState& state)
  311. {
  312.   CV_FUNCNAME( "hvGetState" ); // declare cvFuncName
  313.   __BEGIN__;
  314.   if (!g_pHandVu) {
  315.     CV_ERROR(CV_StsError, "HandVu not initialized");
  316.   }
  317.   try {
  318.     HVState hsta;
  319.     g_pHandVu->GetState(obj_id, hsta);
  320.     state.obj_id = hsta.m_obj_id;
  321.     state.tracked = hsta.m_tracked;
  322.     state.recognized = hsta.m_recognized;
  323.     state.center_xpos = hsta.m_center_xpos;
  324.     state.center_ypos = hsta.m_center_ypos;
  325.     state.scale = hsta.m_scale;
  326.     state.posture = hsta.m_posture;
  327.     state.tstamp = hsta.m_tstamp;
  328.   } catch (HVException& hve) {
  329.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  330.   }
  331.   __END__;
  332. }
  335. void hvSetDetectionArea(int left, int top, int right, int bottom)
  336. {
  337.   CV_FUNCNAME( "hvSetDetectionArea" ); // declare cvFuncName
  338.   __BEGIN__;
  339.   if (!g_pHandVu) {
  340.     CV_ERROR(CV_StsError, "HandVu not initialized");
  341.   }
  342.   try {
  343.     g_pHandVu->SetDetectionArea(left, top, right, bottom);
  344.   } catch (HVException& hve) {
  345.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  346.   }
  347.   __END__;
  348. }
  350. void hvGetDetectionArea(int* pLeft, int* pTop, int* pRight, int* pBottom)
  351. {
  352.   CV_FUNCNAME( "hvAsyncProcessFrame" ); // declare cvFuncName
  353.   __BEGIN__;
  354.   if (!g_pHandVu) {
  355.     CV_ERROR(CV_StsError, "HandVu not initialized");
  356.   }
  357.   try {
  358.     CQuadruple area;
  359.     g_pHandVu->GetDetectionArea(area);
  360.     *pLeft = (int) area.left;
  361.     *pTop = (int) area.top;
  362.     *pRight = (int) area.right;
  363.     *pBottom = (int) area.bottom;
  364.   } catch (HVException& hve) {
  365.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  366.   }
  367.   __END__;
  368. }
  370. void hvRecomputeNormalLatency()
  371. {
  372.   CV_FUNCNAME( "hvRecomputeNormalLatency" ); // declare cvFuncName
  373.   __BEGIN__;
  374.   if (!g_pHandVu) {
  375.     CV_ERROR(CV_StsError, "HandVu not initialized");
  376.   }
  377.   try {
  378.     g_pHandVu->RecomputeNormalLatency();
  379.   } catch (HVException& hve) {
  380.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  381.   }
  382.   __END__;
  383. }
  385. void hvSetOverlayLevel(int level)
  386. {
  387.   CV_FUNCNAME( "hvSetOverlayLevel" ); // declare cvFuncName
  388.   __BEGIN__;
  389.   if (!g_pHandVu) {
  390.     CV_ERROR(CV_StsError, "HandVu not initialized");
  391.   }
  392.   try {
  393.     g_pHandVu->SetOverlayLevel(level);
  394.   } catch (HVException& hve) {
  395.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  396.   }
  397.   __END__;
  398. }
  400. int hvGetOverlayLevel()
  401. {
  402.   CV_FUNCNAME( "hvRecomputeNormalLatency" ); // declare cvFuncName
  403.   __BEGIN__;
  404.   if (!g_pHandVu) {
  405.     CV_ERROR(CV_StsError, "HandVu not initialized");
  406.   }
  407.   try {
  408.     int level = g_pHandVu->GetOverlayLevel();
  409.     return level;
  410.   } catch (HVException& hve) {
  411.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  412.   }
  413.   __END__;
  414. }
  417. void hvCorrectDistortion(bool enable)
  418. {
  419.   CV_FUNCNAME( "hvCorrectDistortion" ); // declare cvFuncName
  420.   __BEGIN__;
  421.   if (!g_pHandVu) {
  422.     CV_ERROR(CV_StsError, "HandVu not initialized");
  423.   }
  424.   try {
  425.     g_pHandVu->CorrectDistortion(enable);
  426.   } catch (HVException& hve) {
  427.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  428.   }
  429.   __END__;
  430. }
  432. bool hvIsCorrectingDistortion()
  433. {
  434.   CV_FUNCNAME( "hvIsCorrectingDistortion" ); // declare cvFuncName
  435.   __BEGIN__;
  436.   if (!g_pHandVu) {
  437.     CV_ERROR(CV_StsError, "HandVu not initialized");
  438.   }
  439.   try {
  440.     return g_pHandVu->IsCorrectingDistortion();
  441.   } catch (HVException& hve) {
  442.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  443.   }
  444.   __END__;
  445. }
  447. bool hvCanCorrectDistortion()
  448. {
  449.   CV_FUNCNAME( "hvCanCorrectDistortion" ); // declare cvFuncName
  450.   __BEGIN__;
  451.   if (!g_pHandVu) {
  452.     CV_ERROR(CV_StsError, "HandVu not initialized");
  453.   }
  454.   try {
  455.     return g_pHandVu->CanCorrectDistortion();
  456.   } catch (HVException& hve) {
  457.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  458.   }
  459.   __END__;
  460. }
  462. void hvSetAdjustExposure(bool enable)
  463. {
  464.   CV_FUNCNAME( "hvSetAdjustExposure" ); // declare cvFuncName
  465.   __BEGIN__;
  466.   if (!g_pHandVu) {
  467.     CV_ERROR(CV_StsError, "HandVu not initialized");
  468.   }
  469.   try {
  470.     g_pHandVu->SetAdjustExposure(enable);
  471.   } catch (HVException& hve) {
  472.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  473.   }
  474.   __END__;
  475. }
  477. bool hvCanAdjustExposure()
  478. {
  479.   CV_FUNCNAME( "hvCanAdjustExposure" ); // declare cvFuncName
  480.   __BEGIN__;
  481.   if (!g_pHandVu) {
  482.     CV_ERROR(CV_StsError, "HandVu not initialized");
  483.   }
  484.   try {
  485.     return g_pHandVu->CanAdjustExposure();
  486.   } catch (HVException& hve) {
  487.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  488.   }
  489.   __END__;
  490. }
  492. bool hvIsAdjustingExposure()
  493. {
  494.   CV_FUNCNAME( "hvIsAdjustingExposure" ); // declare cvFuncName
  495.   __BEGIN__;
  496.   if (!g_pHandVu) {
  497.     CV_ERROR(CV_StsError, "HandVu not initialized");
  498.   }
  499.   try {
  500.     return g_pHandVu->IsAdjustingExposure();
  501.   } catch (HVException& hve) {
  502.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  503.   }
  504.   __END__;
  505. }
  508. void hvSetLogfile(const string& filename)
  509. {
  510.   CV_FUNCNAME( "hvSetLogfile" ); // declare cvFuncName
  511.   __BEGIN__;
  512.   if (!g_pHandVu) {
  513.     CV_ERROR(CV_StsError, "HandVu not initialized");
  514.   }
  515.   try {
  516.     g_pHandVu->SetLogfile(filename);
  517.   } catch (HVException& hve) {
  518.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  519.   }
  520.   __END__;
  521. }
  523. void hvSaveScannedArea(IplImage* pImg, string& picfile)
  524. {
  525.   CV_FUNCNAME( "hvSaveScannedArea" ); // declare cvFuncName
  526.   __BEGIN__;
  527.   if (!g_pHandVu) {
  528.     CV_ERROR(CV_StsError, "HandVu not initialized");
  529.   }
  530.   try {
  531.     g_pHandVu->SaveScannedArea(pImg, picfile);
  532.   } catch (HVException& hve) {
  533.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  534.   }
  535.   __END__;
  536. }
  538. void hvSaveImageArea(IplImage* pImg, int left, int top, int right, int bottom, string& picfile)
  539. {
  540.   CV_FUNCNAME( "hvSaveImageArea" ); // declare cvFuncName
  541.   __BEGIN__;
  542.   if (!g_pHandVu) {
  543.     CV_ERROR(CV_StsError, "HandVu not initialized");
  544.   }
  545.   try {
  546.     g_pHandVu->SaveImageArea(pImg, CRect(left, top, right, bottom), picfile);
  547.   } catch (HVException& hve) {
  548.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  549.   }
  550.   __END__;
  551. }
  553. void hvSetSaveFilenameRoot(const string& fname_root)
  554. {
  555.   CV_FUNCNAME( "hvSetSaveFilenameRoot" ); // declare cvFuncName
  556.   __BEGIN__;
  557.   if (!g_pHandVu) {
  558.     CV_ERROR(CV_StsError, "HandVu not initialized");
  559.   }
  560.   try {
  561.     g_pHandVu->SetSaveFilenameRoot(fname_root);
  562.   } catch (HVException& hve) {
  563.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  564.   }
  565.   __END__;
  566. }
  569. void hvSetDoTrack(bool do_track)
  570. {
  571.   CV_FUNCNAME( "hvSetDoTrack" ); // declare cvFuncName
  572.   __BEGIN__;
  573.   if (!g_pHandVu) {
  574.     CV_ERROR(CV_StsError, "HandVu not initialized");
  575.   }
  576.   try {
  577.     g_pHandVu->SetDoTrack(do_track);
  578.   } catch (HVException& hve) {
  579.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  580.   }
  581.   __END__;
  582. }
  585. void hvStartGestureServer(int port, int max_num_clients)
  586. {
  587.   CV_FUNCNAME( "hvStartGestureServer" ); // declare cvFuncName
  588.   __BEGIN__;
  589.   if (!g_pHandVu) {
  590.     CV_ERROR(CV_StsError, "HandVu not initialized");
  591.   }
  592.   try {
  593.     g_pservers.push_back(new GestureServerStream(port, max_num_clients));
  594.     g_pservers.back()->Start();
  595.   } catch (HVException& hve) {
  596.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  597.   }
  598.   __END__;
  599. }
  601. void hvStartOSCServer(const string& desthost, int destport)
  602. {
  603.   CV_FUNCNAME( "hvStartOSCServer" ); // declare cvFuncName
  604.   __BEGIN__;
  605.   if (!g_pHandVu) {
  606.     CV_ERROR(CV_StsError, "HandVu not initialized");
  607.   }
  608.   try {
  609.     g_pservers.push_back(new GestureServerOSC(desthost, destport));
  610.     g_pservers.back()->Start();
  611.   } catch (HVException& hve) {
  612.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  613.   }
  614.   __END__;
  615. }
  617. void hvStopGestureServer(int /*port*/)
  618. {
  619.   CV_FUNCNAME( "hvStopGestureServer" ); // declare cvFuncName
  620.   __BEGIN__;
  621.   if (!g_pHandVu) {
  622.     CV_ERROR(CV_StsError, "HandVu not initialized");
  623.   }
  624.   try {
  625.     throw HVException("sorry, stop server not implemented");
  626.   } catch (HVException& hve) {
  627.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  628.   }
  629.   __END__;
  630. }
  632. void hvStopOSCServer(const string& /*desthost*/, int /*destport*/)
  633. {
  634.   CV_FUNCNAME( "hvStopOSCServer" ); // declare cvFuncName
  635.   __BEGIN__;
  636.   if (!g_pHandVu) {
  637.     CV_ERROR(CV_StsError, "HandVu not initialized");
  638.   }
  639.   try {
  640.     throw HVException("sorry, stop server not implemented");
  641.   } catch (HVException& hve) {
  642.     CV_ERROR(CV_StsError, hve.GetMessage().c_str());
  643.   }
  644.   __END__;
  645. }
  647. void HandVu::SendEvent() const
  648. {
  649.   HVState state;
  650.   GetState(0, state);
  651.   for (int s=0; s<(int)g_pservers.size(); s++) {
  652.     g_pservers[s]->Send(state);
  653.   }
  654. }
  657. /** verbosity: 0 minimal, 3 maximal
  658. */
  659. void hvGetVersion(string& version, int verbosity)
  660. {
  661. //  todo: version = HV_CURRENT_VERSION_STRING;
  662.   version = "handvu version beta2";
  663.   if (verbosity>=1) {
  664. #if defined(WIN32)
  665.     version = version + ", win32";
  666. #elif defined(TARGET_SYSTEM)
  667.     version = version + ", "TARGET_SYSTEM;
  668. #else
  669. #error TARGET_SYSTEM must be defined
  670. #endif
  672. #if defined(DEBUG)
  673.     version = version + " debug";
  674. #endif
  676. #ifdef USE_MFC
  677.     version = version + ", MFC";
  678. #endif
  679.   }
  681.   if (verbosity>=2) {
  682.     version = version + ", built on "__DATE__" at "__TIME__;
  683.   }
  685.   if (verbosity>=3) {
  686.     version = version + "nCVS id: $Id: HandVu_Cintf.cpp,v 1.3 2005/10/30 23:00:43 matz Exp $";
  687.   }
  689.   string cubicles_version;
  690.   cuGetVersion(cubicles_version, verbosity);
  691.   version = version + "n" + cubicles_version;
  692. }