Changeset 571 for trunk

Timestamp:

06/09/11 11:54:12 (12 months ago)

Author:

mschlatt

Message:

Modified MT-interface (Users added, now receiving Kinect Messages)

Location:

trunk/avango-display

Files:

• include/avango/display/mt/MultitouchDevice.h (modified) (5 diffs)
• include/avango/display/mt/MultitouchFinger.h (modified) (3 diffs)
• src/avango/display/mt/MultitouchDevice.cpp (modified) (10 diffs)
• src/avango/display/mt/MultitouchFinger.cpp (modified) (3 diffs)
• src/avango/display/mt/multitouch/FingerClient.cpp (modified) (11 diffs)
• src/avango/display/mt/multitouch/FingerClient.h (modified) (4 diffs)
• src/avango/display/mt/multitouch/FingerInfo.cpp (modified) (1 diff)
• src/avango/display/mt/multitouch/FingerInfo.h (modified) (4 diffs)
• src/avango/display/mt/multitouch/FingerListener.h (modified) (1 diff)
• wrapper/avango/display/mt/_display_mt.cpp (modified) (2 diffs)

trunk/avango-display/include/avango/display/mt/MultitouchDevice.h

@@ -43 +43 @@
     namespace mt
     {
-      class AV_DISPLAY_MT_DLL MultitouchDevice : public FieldContainer, public FingerListener
+      class AV_DISPLAY_MT_DLL MultitouchDevice : public FieldContainer, public FingerListener, public UserListener
       {
         AV_FC_DECLARE();
@@ -56 +56 @@
         MFMultitouchFinger Removed;
 
+                MFMultitouchUser AddedUsers;
+        MFMultitouchUser AvailableUsers;
+        MFMultitouchUser RemovedUsers;
+
         SFFloat TimeIn;
 
@@ -61 +65 @@
         SFInt FilterSize;
 
+                void handleFingers();
+                void handleUsers();
         /* virtual */ void evaluate();
 
@@ -68 +74 @@
         void fingerRemoved(FingerInfo *pFingerInfo);
 
+                // FingerListener interface
+        void userAdded(UserInfo *pUserInfo);
+        void userMoved(UserInfo *pUserInfo);
+        void userRemoved(UserInfo *pUserInfo);
+
       private:
+
+                void processMessages(std::queue< std::pair< FingerClient::MyMessage, int > > &messages);
 
         FingerClient *mFingerClient;
@@ -76 +89 @@
           bool do_move;
           bool do_remove;
-          int finger_id;
+          int finger_id, user_id;
           Vec2 position;
                   float angle, width, height, area;
           Link<MultitouchFinger> finger;
-          FingerAction(int _finger_id = -1) : do_add(false), do_move(false), do_remove(false), finger_id(_finger_id)
+          FingerAction(int _finger_id = -1) : do_add(false), do_move(false), do_remove(false), finger_id(_finger_id), user_id(-1)
+          {
+          }
+        };
+                struct UserAction
+        {
+          bool do_add;
+          bool do_move;
+          bool do_remove;
+          int user_id;
+          Link<MultitouchUser> user;
+          UserAction(int _user_id = -1) : do_add(false), do_move(false), do_remove(false), user_id(_user_id)
           {
           }
         };
         typedef std::map<int, FingerAction> FingerMap;
+                typedef std::map<int, UserAction> UserMap;
         FingerMap mFingerMap;
+                UserMap mUserMap;
         boost::mutex mMutex;
+                int mOriginalPort, mReceivedPort;
+                double mReceivedPortTime;
       };
     }

trunk/avango-display/include/avango/display/mt/MultitouchFinger.h

@@ -44 +44 @@
 
       public:
-        MultitouchFinger(int _id = -1, OsgVec2 _position = OsgVec2(), float _creationTime= 0.0, float _angle = 0.0, float _width = 0.0, float _height = 0.0, float _area = 0.0);
+        MultitouchFinger(int _id = -1, OsgVec2 _position = OsgVec2(), float _creationTime= 0.0, float _angle = 0.0, float _width = 0.0, float _height = 0.0, float _area = 0.0, int _user_id = -1);
         virtual ~MultitouchFinger();
 
-        av::SFInt Identifier;
+        av::SFInt Identifier, UserID;
         av::osg::SFVec2 Position;
                 av::SFFloat Angle, Width, Height, Area;
@@ -56 +56 @@
       typedef SingleField<Link<MultitouchFinger> > SFMultitouchFinger;
       typedef MultiField<Link<MultitouchFinger> > MFMultitouchFinger;
+
+
+          class AV_DISPLAY_MT_DLL MultitouchUser : public FieldContainer
+      {
+        AV_FC_DECLARE();
+
+      public:
+        MultitouchUser(int _id = -1, float _creationTime= 0.0);
+        virtual ~MultitouchUser();
+
+        av::SFInt Identifier;
+        av::SFFloat CreationTime;
+
+      };
+
+      typedef SingleField<Link<MultitouchUser> > SFMultitouchUser;
+      typedef MultiField<Link<MultitouchUser> > MFMultitouchUser;
     }
   }
@@ -62 +79 @@
 template class AV_DISPLAY_MT_DLL SingleField<Link<display::mt::MultitouchFinger> >;
 template class AV_DISPLAY_MT_DLL MultiField<Link<display::mt::MultitouchFinger> >;
+
+template class AV_DISPLAY_MT_DLL SingleField<Link<display::mt::MultitouchUser> >;
+template class AV_DISPLAY_MT_DLL MultiField<Link<display::mt::MultitouchUser> >;
 #endif
 }

trunk/avango-display/src/avango/display/mt/MultitouchDevice.cpp

@@ -39 +39 @@
 AV_FC_DEFINE(av::display::mt::MultitouchDevice);
 
-av::display::mt::MultitouchDevice::MultitouchDevice()
+av::display::mt::MultitouchDevice::MultitouchDevice() : mOriginalPort(3333), mReceivedPort(mOriginalPort), mReceivedPortTime(timeGetTime())
 {
   AV_FC_ADD_FIELD(Added, MFMultitouchFinger::ContainerType());
@@ -48 +48 @@
   AV_FC_ADD_FIELD(TimeIn, 0.0);
 
-  mFingerClient = new FingerClient(3333);
+  mFingerClient = new FingerClient(mOriginalPort);
 
   if (mFingerClient)
   {
     mFingerClient->registerFingerListener(this);
+        mFingerClient->registerUserListener(this);
 
     alwaysEvaluate(true);
@@ -74 +75 @@
 }
 
-/* virtual */ void
-av::display::mt::MultitouchDevice::evaluate()
-{
-  boost::mutex::scoped_lock mLock(mMutex);
-
+void
+av::display::mt::MultitouchDevice::processMessages(std::queue< std::pair< FingerClient::MyMessage, int > > &messages)
+{
+        while(!messages.empty())
+        {
+                std::pair< FingerClient::MyMessage, int > message = messages.front();
+                messages.pop();
+                switch(message.first)
+                {
+                case FingerClient::MYMESS_SET_PORT:
+                        mReceivedPort = message.second;
+                        mReceivedPortTime = timeGetTime();
+                    break;
+                default:
+                        //todo: messages pushen
+                        break;
+                };
+        }
+}
+
+void
+av::display::mt::MultitouchDevice::handleFingers()
+{
   mFingerClient->setPositionHistorySize(FilterSize.getValue());
 
@@ -110 +129 @@
     if (action.do_add)
     {
-      action.finger = new MultitouchFinger(action.finger_id, ::osg::Vec2(action.position.x, action.position.y), time, action.angle, action.width, action.height, action.area);
+      action.finger = new MultitouchFinger(action.finger_id, ::osg::Vec2(action.position.x, action.position.y), time, action.angle, action.width, action.height, action.area, action.user_id);
       Added.add1Value(action.finger);
       action.do_add = false;
@@ -121 +140 @@
           action.finger->Height.setValue(action.height);
           action.finger->Area.setValue(action.area);
+          action.finger->UserID.setValue(action.user_id);
       action.do_move = false;
     }
@@ -130 +150 @@
           action.finger->Height.setValue(action.height);
           action.finger->Area.setValue(action.area);
+          action.finger->UserID.setValue(action.user_id);
       Available.remove1Value(action.finger);
       Removed.add1Value(action.finger);
@@ -138 +159 @@
     ++iter;
   }
+}
+
+void
+av::display::mt::MultitouchDevice::handleUsers()
+{
+  if (!AddedUsers.getValue().empty())
+  {
+    // hand over to Available
+    MFMultitouchUser::ContainerType::const_iterator iter = AddedUsers.getValue().begin();
+    MFMultitouchUser::ContainerType::const_iterator iter_end = AddedUsers.getValue().end();
+    for (; iter != iter_end; ++iter)
+      AvailableUsers.add1Value(*iter);
+
+    // clear Added
+    AddedUsers.setValue(MFMultitouchUser::ContainerType());
+  }
+
+  if (!RemovedUsers.getValue().empty())
+  {
+    // clear removed
+    RemovedUsers.setValue(MFMultitouchUser::ContainerType());
+  }
+
+  UserMap::iterator iter = mUserMap.begin();
+  UserMap::iterator iter_end = mUserMap.end();
+
+  float time = TimeIn.getValue();
+
+  while (iter != iter_end)
+  {
+    UserAction &action = iter->second;
+    if (action.do_add)
+    {
+      action.user = new MultitouchUser(action.user_id, time);
+      AddedUsers.add1Value(action.user);
+      action.do_add = false;
+    }
+    else if (action.do_move)
+    {
+      action.do_move = false;
+    }
+    else if (action.do_remove)
+    {
+      AvailableUsers.remove1Value(action.user);
+      RemovedUsers.add1Value(action.user);
+      mUserMap.erase(iter++);
+      action.do_remove = false;
+      continue;
+    }
+    ++iter;
+  }
+}
+
+/* virtual */ void
+av::display::mt::MultitouchDevice::evaluate()
+{
+  boost::mutex::scoped_lock mLock(mMutex);
+
+  processMessages(mFingerClient->getMessages());
+
+  if(mFingerClient->getPort() != mOriginalPort && (timeGetTime() - mReceivedPortTime) > 500.0)
+        mReceivedPort = mOriginalPort;
+
+  if(mReceivedPort != mFingerClient->getPort())
+  {
+          if (mFingerClient)
+                delete mFingerClient;
+          mFingerClient = new FingerClient(mReceivedPort);
+          if (mFingerClient)
+          {
+                mFingerClient->registerFingerListener(this);
+                mFingerClient->registerUserListener(this);
+          }
+  } 
+
+  handleFingers();
+  handleUsers();
 }
 
@@ -158 +256 @@
         action.height = pFingerInfo->getHeight();
         action.area = pFingerInfo->getArea();
+        action.user_id = pFingerInfo->getUserId();
     action.do_add = true;
   }
@@ -176 +275 @@
         action.height = pFingerInfo->getHeight();
         action.area = pFingerInfo->getArea();
+        action.user_id = pFingerInfo->getUserId();
     action.do_move = true;
   }
@@ -200 +300 @@
           action.height = pFingerInfo->getHeight();
           action.area = pFingerInfo->getArea();
+          action.user_id = pFingerInfo->getUserId();
       action.do_remove = true;
     }
   }
 }
+
+void
+av::display::mt::MultitouchDevice::userAdded(UserInfo *pUserInfo)
+{
+  boost::mutex::scoped_lock mLock(mMutex);
+  // FIXME: Between two frames (evaluate() calls), it can happen, that a finger id
+  // is added again, before the former one was removed completely.
+  // In this case this id is ignored.
+  const int user_id = pUserInfo->getUserId();
+  UserMap::iterator iter = mUserMap.find(user_id);
+  if (iter == mUserMap.end())
+  {
+    iter = mUserMap.insert(UserMap::value_type(user_id, UserAction(user_id))).first;
+    UserAction &action = iter->second;
+    action.do_add = true;
+  }
+}
+
+void
+av::display::mt::MultitouchDevice::userMoved(UserInfo *pUserInfo)
+{
+  boost::mutex::scoped_lock mLock(mMutex);
+  const int user_id = pUserInfo->getUserId();
+  UserMap::iterator iter = mUserMap.find(user_id);
+  if (iter != mUserMap.end())
+  {
+    UserAction &action = iter->second;
+    action.do_move = true;
+  }
+}
+
+void
+av::display::mt::MultitouchDevice::userRemoved(UserInfo *pUserInfo)
+{
+  boost::mutex::scoped_lock mLock(mMutex);
+  const int user_id = pUserInfo->getUserId();
+  UserMap::iterator iter = mUserMap.find(user_id);
+  if (iter != mUserMap.end())
+  {
+    UserAction &action = iter->second;
+    if (action.do_add)
+      // Avango should not see fingers that are deleted before being added officially, so we delete them here directly
+      mUserMap.erase(iter);
+    else
+    {
+      action.do_remove = true;
+    }
+  }
+}

trunk/avango-display/src/avango/display/mt/MultitouchFinger.cpp

@@ -38 +38 @@
 AV_FIELD_DEFINE(av::display::mt::MFMultitouchFinger);
 
-av::display::mt::MultitouchFinger::MultitouchFinger(int _id, ::osg::Vec2 _position, float _creationTime, float _angle, float _width, float _height, float _area)
+av::display::mt::MultitouchFinger::MultitouchFinger(int _id, ::osg::Vec2 _position, float _creationTime, float _angle, float _width, float _height, float _area, int _user_id)
 {
   AV_FC_ADD_FIELD(Identifier, _id);
@@ -47 +47 @@
   AV_FC_ADD_FIELD(Height, _height);
   AV_FC_ADD_FIELD(Area, _area);
+  AV_FC_ADD_FIELD(UserID, _user_id);
 }
 
@@ -65 +66 @@
   }
 }
+
+
+AV_FC_DEFINE(av::display::mt::MultitouchUser);
+
+AV_FIELD_DEFINE(av::display::mt::SFMultitouchUser);
+AV_FIELD_DEFINE(av::display::mt::MFMultitouchUser);
+
+av::display::mt::MultitouchUser::MultitouchUser(int _id, float _creationTime)
+{
+  AV_FC_ADD_FIELD(Identifier, _id);
+  AV_FC_ADD_FIELD(CreationTime, _creationTime);
+}
+
+av::display::mt::MultitouchUser::~MultitouchUser()
+{}
+
+void
+av::display::mt::MultitouchUser::initClass()
+{
+  if (!isTypeInitialized())
+  {
+    av::FieldContainer::initClass();
+
+    AV_FC_INIT(av::FieldContainer, av::display::mt::MultitouchUser, true);
+
+    SFMultitouchFinger::initClass("av::display::mt::SFMultitouchUser", "av::Field");
+    MFMultitouchFinger::initClass("av::display::mt::MFMultitouchUser", "av::Field");
+  }
+}

trunk/avango-display/src/avango/display/mt/multitouch/FingerClient.cpp

@@ -14 +14 @@
 
 
-FingerClient::FingerClient(int port) : fingerlistener(0), historysize(0), current_fseq(0)
-{
+FingerClient::FingerClient(int port) : fingerlistener(0), historysize(0), mPort(port)
+{
+  address_patterns.push_back("/tuio/2Dcur");
+  address_patterns.push_back("/tuio/2Dobj");
+  address_patterns.push_back("/tuio/2Dblb");
+  address_patterns.push_back("/tuio/_kinect");
+  current_fseqs.resize(address_patterns.size(), 0);
+
   socket = 0;
   try
@@ -55 +61 @@
 }
 
+void FingerClient::registerUserListener(UserListener *listener)
+{
+  boost::mutex::scoped_lock lock(mutex);
+  userlistener = listener;
+}
+
 void
 FingerClient::setPositionHistorySize(unsigned int size)
@@ -81 +93 @@
 FingerClient::ProcessBundle(const osc::ReceivedBundle &bundle, const IpEndpointName &remoteEndpoint)
 {
-  osc::int32 fseq = current_fseq;
+  osc::int32 fseq = 0;
+  int pattern = -1;
 
   osc::ReceivedBundle::const_iterator iter = bundle.ElementsBegin();
   osc::ReceivedBundle::const_iterator iter_end = bundle.ElementsEnd();
 
+  //std::cout << "Received Bundle" << std::endl;
   // find fseq
   for (; iter != iter_end; ++iter)
@@ -97 +111 @@
         osc::ReceivedMessageArgumentStream args = message.ArgumentStream();
 
-        if (strcmp(message.AddressPattern(), "/tuio/2Dcur") == 0
-                        || strcmp(message.AddressPattern(), "/tuio/2Dobj") == 0
-                        || strcmp(message.AddressPattern(), "/tuio/2Dblb") == 0)
+                {
+                        osc::ReceivedMessageArgumentStream args2 = message.ArgumentStream();
+                        //std::cout << message.AddressPattern() << " ";
+
+                        if (!args2.Eos())
+                        {
+                                const char *cmd;
+                                args2 >> cmd;
+                                //std::cout << cmd;
+                        }
+                        //args2 >> osc::EndMessage;
+                }
+                //std::cout << std::endl;
+
+                for(unsigned int i = 0; i < address_patterns.size(); ++i)
+                {
+                        if (strcmp(message.AddressPattern(), address_patterns[i].data()) == 0)
+                        {
+                          pattern = (int)i;
+                          const char *cmd;
+                          args >> cmd;
+
+                          if (strcmp(cmd, "fseq") == 0)
+                                args >> fseq >> osc::EndMessage;
+                        }
+                }
+      }
+      catch (osc::Exception &e)
+      {
+        logger.error() << "Error while parsing TUIO message: " << e.what();
+      }
+    }
+  }
+
+  if (pattern >= 0)
+  {
+          // if fseq is negative, then reset current_fseq to 0
+          if (fseq < 0)
+                current_fseqs[pattern] = fseq = 0;
+
+          if (fseq >= current_fseqs[pattern])
+          {
+                current_fseqs[pattern] = fseq;
+
+                // process other messages
+                iter = bundle.ElementsBegin();
+                for (; iter != iter_end; ++iter)
+                {
+                  osc::ReceivedBundleElement element = *iter;
+                  if (iter->IsBundle())
+                        ProcessBundle(osc::ReceivedBundle(element), remoteEndpoint);
+                  else
+                  {
+                        try
+                        {
+                          ProcessMessage(osc::ReceivedMessage(element), remoteEndpoint);
+                        }
+                        catch (osc::Exception &e)
+                        {
+                          logger.error() << "Error while parsing TUIO message: " << e.what();
+                        }
+                  }
+                }
+          }
+  }
+}
+
+osc::int32
+FingerClient::getUserIdForFinger(osc::int32 s_id)
+{
+        for(std::map<osc::int32, UserInfo*>::iterator it = uid_map.begin(); it != uid_map.end(); ++it)
+        {
+                std::set< int >::iterator itID = it->second->FingerIds().find(s_id);
+                if(itID != it->second->FingerIds().end())
+                        return *itID;
+        }
+        return -1;
+}
+
+void
+FingerClient::addUserIdToFinger(osc::int32 u_id, osc::int32 s_id)
+{
+  std::map<osc::int32, FingerInfo*>::iterator iter = cursor_id_map.find(s_id);
+  if (iter != cursor_id_map.end())
+  {
+    FingerInfo *fingerinfo = iter->second;
+
+        /*if(fingerinfo->getUserId() != u_id)
+                std::cout << "Finger " << s_id << " switch from user " << fingerinfo->getUserId() << " to " << u_id << std::endl;*/
+
+        fingerinfo->setUserId(u_id);
+      {
+                FingerListener *fingerlistener_secure;
+                {
+                        boost::mutex::scoped_lock lock(mutex);
+                        fingerlistener_secure = fingerlistener;
+                }
+                if (fingerlistener_secure)
+                        fingerlistener_secure->fingerMoved(fingerinfo);
+      }
+  }
+}
+
+void
+FingerClient::removeUserIdFromFinger(osc::int32 s_id)
+{
+  std::map<osc::int32, FingerInfo*>::iterator iter = cursor_id_map.find(s_id);
+  if (iter != cursor_id_map.end())
+  {
+    FingerInfo *fingerinfo = iter->second;
+        /*if(fingerinfo->getUserId() != -1)
+                std::cout << "Finger " << s_id << " switch from user " << fingerinfo->getUserId() << " to " << -1 << std::endl;*/
+        fingerinfo->setUserId(-1);
+
+      {
+        FingerListener *fingerlistener_secure;
+                {
+                        boost::mutex::scoped_lock lock(mutex);
+                        fingerlistener_secure = fingerlistener;
+                }
+                if (fingerlistener_secure)
+                        fingerlistener_secure->fingerMoved(fingerinfo);
+      }
+  }
+}
+void
+FingerClient::ProcessKinectMessage(const osc::ReceivedMessage &message, const IpEndpointName &remoteEndpoint)
+{
+        osc::ReceivedMessageArgumentStream args = message.ArgumentStream();
+
+        const char *cmd;
+        args >> cmd;
+
+        //std::cout << message.AddressPattern();
+
+        if (strcmp(cmd, "set") == 0)
+    {
+          //std::cout << " set";
+          static osc::int32 u_id;
+          std::set< int > finger_ids;
+
+          args >> u_id;
+          //std::cout << " U" << u_id;
+
+          osc::int32 s_id;
+      while (!args.Eos()) {
+        args >> s_id;
+                //std::cout << " F" << s_id;
+        finger_ids.insert(s_id);
+      }
+      args >> osc::EndMessage;
+          //std::cout << std::endl;
+
+      std::map<osc::int32, UserInfo*>::iterator iter = uid_map.find(u_id);
+      if (iter == uid_map.end())
+      {
+        UserInfo *userinfo = new UserInfo(u_id);
+        if (userinfo)
         {
-          const char *cmd;
-          args >> cmd;
-
-          if (strcmp(cmd, "fseq") == 0)
-            args >> fseq >> osc::EndMessage;
+                  userinfo->FingerIds() = finger_ids;
+                  for(std::set< int >::iterator it = finger_ids.begin(), end = finger_ids.end(); it != end; ++it)
+                        addUserIdToFinger(u_id, *it);
+
+          uid_map[u_id] = userinfo;
+          alive_uids.insert(u_id);
+
+                  UserListener *userlistener_secure;
+                  {
+                          boost::mutex::scoped_lock lock(mutex);
+                          userlistener_secure = userlistener;
+                  }
+                  if (userlistener_secure)
+                          userlistener_secure->userAdded(userinfo);
         }
       }
-      catch (osc::Exception &e)
-      {
-        logger.error() << "Error while parsing TUIO message: " << e.what();
-      }
-    }
-  }
-
-  // if fseq is negative, then reset current_fseq to 0
-  if (fseq < 0)
-    current_fseq = fseq = 0;
-
-  if (fseq >= current_fseq)
-  {
-    current_fseq = fseq;
-
-    // process other messages
-    iter = bundle.ElementsBegin();
-    for (; iter != iter_end; ++iter)
-    {
-      osc::ReceivedBundleElement element = *iter;
-      if (iter->IsBundle())
-        ProcessBundle(osc::ReceivedBundle(element), remoteEndpoint);
       else
       {
-        try
+                int changed = false;
+        UserInfo *userinfo = iter->second;
+        
+                std::set< int > &fIds = userinfo->FingerIds();
+
+                // add new fingers
+                for(std::set< int >::iterator it = finger_ids.begin(), end = finger_ids.end(); it != end; ++it)
+                {
+                        if(fIds.insert(*it).second)
+                        {
+                                addUserIdToFinger(u_id, *it);
+                                //std::cout << "User ID " << u_id << " added to finger " << *it << std::endl;
+                                changed = true;
+                        }
+                }
+                // remove left fingers
+                if(fIds.size() > finger_ids.size())
+                {
+                        std::vector< int > remove_fids;
+                        for(std::set< int >::iterator it = fIds.begin(), end = fIds.end(); it != end; ++it)
+                        {
+                                if(finger_ids.find(*it) == finger_ids.end())
+                                {
+                                        removeUserIdFromFinger(*it);
+                                        remove_fids.push_back(*it);
+                                }
+                        }
+                        for(unsigned int i = 0; i < remove_fids.size(); ++i)
+                                fIds.erase(remove_fids[i]);
+                        changed = true;
+                }
+
+                if(changed)
         {
-          ProcessMessage(osc::ReceivedMessage(element), remoteEndpoint);
+                        UserListener *userlistener_secure;
+                          {
+                                  boost::mutex::scoped_lock lock(mutex);
+                                  userlistener_secure = userlistener;
+                          }
+                          if (userlistener_secure)
+                                  userlistener_secure->userMoved(userinfo);
         }
-        catch (osc::Exception &e)
-        {
-          logger.error() << "Error while parsing TUIO message: " << e.what();
-        }
-      }
-    }
-  }
+      }
+    }
+        else if (strcmp(cmd, "alive") == 0)
+    {
+          //std::cout << " alive";
+      std::set<osc::int32> removed_uids = alive_uids;
+
+      osc::int32 u_id;
+      while (!args.Eos()) {
+        args >> u_id;
+                //std::cout << " " << u_id;
+        removed_uids.erase(u_id);
+      }
+      args >> osc::EndMessage;
+          //std::cout << std::endl;
+
+          UserListener *userlistener_secure;
+          {
+                  boost::mutex::scoped_lock lock(mutex);
+                  userlistener_secure = userlistener;
+          }
+
+      std::set<osc::int32>::const_iterator iter = removed_uids.begin();
+      std::set<osc::int32>::const_iterator iter_end = removed_uids.end();
+      for (; iter != iter_end; ++iter)
+      {
+        u_id = *iter;
+        UserInfo *userinfo = uid_map[u_id];
+        if (userlistener_secure)
+                  userlistener_secure->userRemoved(userinfo);
+        uid_map.erase(u_id);
+        alive_uids.erase(u_id);
+        delete userinfo;
+      }
+    }
 }
 
@@ -148 +370 @@
 FingerClient::ProcessMessage(const osc::ReceivedMessage &message, const IpEndpointName &remoteEndpoint)
 {
+        boost::mutex::scoped_lock lock(mutex2);
+
+        //std::cout << message.AddressPattern();
+        if(strcmp(message.AddressPattern(), "/tuio/_kinect") == 0)
+        {
+                ProcessKinectMessage(message, remoteEndpoint);
+                return;
+        }
+
+
         bool isBlob = false, isObject = false, isValid = true;
         if(strcmp(message.AddressPattern(), "/tuio/2Dobj") == 0)
@@ -182 +414 @@
         if (fingerinfo)
         {
-          FingerListener *fingerlistener_secure;
           {
-            boost::mutex::scoped_lock lock(mutex);
-            fingerlistener_secure = fingerlistener;
             fingerinfo->setPositionHistorySize(historysize);
                         if(isBlob)
@@ -195 +424 @@
                                 fingerinfo->setAngle(angle);
           }
+                  fingerinfo->setUserId(getUserIdForFinger(s_id));
+                  //std::cout << "New finger " << s_id << " from user " << fingerinfo->getUserId() << std::endl;
           cursor_id_map[s_id] = fingerinfo;
           alive_ids.insert(s_id);
-          if (fingerlistener_secure)
-            fingerlistener_secure->fingerAdded(fingerinfo);
+                  FingerListener *fingerlistener_secure;
+                        {
+                                boost::mutex::scoped_lock lock(mutex);
+                                fingerlistener_secure = fingerlistener;
+                        }
+                        if (fingerlistener_secure)
+                                fingerlistener_secure->fingerAdded(fingerinfo);
         }
       }
@@ -207 +443 @@
         if (pos != fingerinfo->getPosition(0))
         {
-          FingerListener *fingerlistener_secure;
           {
-            boost::mutex::scoped_lock lock(mutex);
-            fingerlistener_secure = fingerlistener;
             fingerinfo->setPositionHistorySize(historysize);
                         if(isBlob)
@@ -221 +454 @@
           }
           fingerinfo->addPosition(pos);
-          if (fingerlistener_secure)
-            fingerlistener_secure->fingerMoved(fingerinfo);
+                  FingerListener *fingerlistener_secure;
+                        {
+                                boost::mutex::scoped_lock lock(mutex);
+                                fingerlistener_secure = fingerlistener;
+                        }
+                        if (fingerlistener_secure)
+                                fingerlistener_secure->fingerMoved(fingerinfo);
         }
       }
@@ -238 +476 @@
 
       FingerListener *fingerlistener_secure;
-      {
-        boost::mutex::scoped_lock lock(mutex);
-        fingerlistener_secure = fingerlistener;
-      }
+                {
+                        boost::mutex::scoped_lock lock(mutex);
+                        fingerlistener_secure = fingerlistener;
+                }
+                
 
       std::set<osc::int32>::const_iterator iter = removed_ids.begin();
@@ -250 +489 @@
         FingerInfo *fingerinfo = cursor_id_map[s_id];
         if (fingerlistener_secure)
-          fingerlistener_secure->fingerRemoved(fingerinfo);
+                        fingerlistener_secure->fingerRemoved(fingerinfo);
         cursor_id_map.erase(s_id);
         alive_ids.erase(s_id);

trunk/avango-display/src/avango/display/mt/multitouch/FingerClient.h

@@ -11 +11 @@
 #include <map>
 #include <set>
+#include <queue>
 
 #include "ip/UdpSocket.h"
@@ -23 +24 @@
 {
 public:
+  enum MyMessage
+  {
+          MYMESS_SET_PORT = 0,
+          MYMESS_ENABLE_CALIB
+  };
+
+public:
   FingerClient(int port);
   ~FingerClient();
 
   void registerFingerListener(FingerListener *listener);
+  void registerUserListener(UserListener *listener);
 
   void setPositionHistorySize(unsigned int size);
@@ -35 +44 @@
   void ProcessBundle(const osc::ReceivedBundle &bundle, const IpEndpointName &remoteEndpoint);
   void ProcessMessage(const osc::ReceivedMessage &message, const IpEndpointName &remoteEndpoint);
+
+  int FingerClient::getPort() const { return mPort; }
+  std::queue< std::pair< MyMessage, int > > &getMessages() { return mMessages; }
 
 private:
@@ -46 +58 @@
   };
 
+  osc::int32 getUserIdForFinger(osc::int32 s_id);
+  void addUserIdToFinger(osc::int32 u_id, osc::int32 s_id);
+  void removeUserIdFromFinger(osc::int32 s_id);
+  void ProcessKinectMessage(const osc::ReceivedMessage &message, const IpEndpointName &remoteEndpoint);
+
   boost::thread *thread;
-  boost::mutex mutex;
+  boost::mutex mutex, mutex2;
 
   FingerListener *fingerlistener;
+  UserListener *userlistener;
   unsigned int historysize;
   UdpListeningReceiveSocket *socket;
   std::map<osc::int32, FingerInfo*> cursor_id_map;
-  std::set<osc::int32> alive_ids;
-  osc::int32 current_fseq;
+  std::map<osc::int32, UserInfo*> uid_map;
+  std::set<osc::int32> alive_ids, alive_uids;
+  std::vector< osc::int32 > current_fseqs;
+  std::vector< std::string > address_patterns;
+  int mPort;
+  std::queue< std::pair< MyMessage, int > > mMessages;
 };
 

trunk/avango-display/src/avango/display/mt/multitouch/FingerInfo.cpp

@@ -37 +37 @@
 {
   return m_iFingerId;
+}
+
+int
+FingerInfo::getUserId()
+{
+  return m_iUserId;
+}
+void
+FingerInfo::setUserId(const int id)
+{
+  m_iUserId = id;
 }
 

trunk/avango-display/src/avango/display/mt/multitouch/FingerInfo.h

@@ -3 +3 @@
 
 #include <deque>
+#include <set>
 
 class FingerClient;
@@ -23 +24 @@
 
   int getFingerId();
+  int getUserId();
+  void setUserId(const int id);
 
   void addPosition(Vec2 position);
@@ -41 +44 @@
   typedef std::deque<Vec2> PositionHistory;
 
-  int m_iFingerId;
+  int m_iFingerId, m_iUserId;
   float m_angle, m_width, m_height, m_area;
 
@@ -51 +54 @@
 
 
+class UserInfo
+{
+public:
+  UserInfo(int id) : m_iUserId(id) {}
+  int getUserId() { return m_iUserId; }
+  std::set< int > &FingerIds() { return m_FingerIds; }
+
+private:
+  int m_iUserId;
+  std::set< int > m_FingerIds;
+
+  friend class FingerClient;
+};
+
+
 #endif //FINGERINFO_H

trunk/avango-display/src/avango/display/mt/multitouch/FingerListener.h

@@ -15 +15 @@
 };
 
+class UserListener
+{
+public:
+  virtual ~UserListener(){};
+  virtual void userAdded(UserInfo *pUserInfo) = 0;
+  virtual void userMoved(UserInfo *pUserInfo) = 0;
+  virtual void userRemoved(UserInfo *pUserInfo) = 0;
+};
+
 
 #endif //_FINGERLISTENER_H

trunk/avango-display/wrapper/avango/display/mt/_display_mt.cpp

@@ -50 +50 @@
   av::display::mt::MultitouchDevice::initClass();
   av::display::mt::MultitouchFinger::initClass();
+  av::display::mt::MultitouchUser::initClass();
 
   // define python bindings here
@@ -58 +59 @@
           "Docstring with explanations what this class can be used for.");
 
+  class_<av::display::mt::MultitouchUser, av::Link<av::display::mt::MultitouchUser>, bases<av::FieldContainer>, boost::noncopyable >("MultitouchUser",
+          "Docstring with explanations what this class can be used for.");
+
   register_field<av::display::mt::SFMultitouchFinger>("SFMultitouchFinger");
   register_multifield<av::display::mt::MFMultitouchFinger>("MFMultitouchFinger");
+
+  register_field<av::display::mt::SFMultitouchUser>("SFMultitouchUser");
+  register_multifield<av::display::mt::MFMultitouchUser>("MFMultitouchUser");
 }