hornetseye-kinect 0.1.0 → 0.2.0

data/README.md

@@ -58,3 +58,42 @@ You can load and use the libfreenect wrappers as shown below. This example demon
       end
     end
 
+Here is another example displaying RGB and the depth image while keeping the tilt angle at zero:
+
+    require 'rubygems'
+    require 'hornetseye_kinect'
+    require 'hornetseye_xorg'
+    include Hornetseye
+    class Numeric
+      def clip( range )
+        [ [ self, range.begin ].max, range.end ].min
+      end
+    end
+    colours = Sequence.ubytergb 256
+    for i in 0...256
+      hue = 240 - i * 240.0 / 256.0
+      colours[i] =
+        RGB( ( ( hue - 180 ).abs -  60 ).clip( 0...60 ) * 0xFF / 60.0,
+             ( 120 - ( hue - 120 ).abs ).clip( 0...60 ) * 0xFF / 60.0,
+             ( 120 - ( hue - 240 ).abs ).clip( 0...60 ) * 0xFF / 60.0 )
+    end
+    input = KinectInput.new
+    display = X11Display.new
+    output_depth, output_video = XImageOutput.new, XVideoOutput.new
+    window_depth = X11Window.new display, output_depth, 640, 480
+    window_video = X11Window.new display, output_video, 640, 480
+    window_depth.title = 'Depth'
+    window_video.title = 'Video'
+    window_depth.show
+    window_video.show
+    input.led = KinectInput::LED_RED
+    while display.status?
+      input.tilt = 0.0
+      input.get_state
+      moving = input.tilt_status == KinectInput::TILT_STATUS_MOVING
+      input.led = moving ? KinectInput::LED_RED : KinectInput::LED_GREEN
+      output_video.write input.read_video
+      output_depth.write( ( input.read_depth >> 3 ).lut colours )
+      display.process_events
+    end
+

data/Rakefile

@@ -7,7 +7,7 @@ require 'rake/loaders/makefile'
 require 'rbconfig'
 
 PKG_NAME = 'hornetseye-kinect'
-PKG_VERSION = '0.1.0'
+PKG_VERSION = '0.2.0'
 CFG = RbConfig::CONFIG
 CXX = ENV[ 'CXX' ] || 'g++'
 RB_FILES = FileList[ 'lib/**/*.rb' ]

data/ext/kinectcontext.cc

@@ -26,7 +26,8 @@ using namespace std;
 VALUE KinectContext::cRubyClass = Qnil;
 
 KinectContext::KinectContext(void) throw (Error):
-  m_context(NULL)
+  m_context(NULL), m_mutex(PTHREAD_MUTEX_INITIALIZER), m_cond(PTHREAD_COND_INITIALIZER),
+  m_instances(0)
 {
   freenect_init( &m_context, NULL );
   ERRORMACRO( m_context != NULL, Error, , "Initialisation of libfreenect failed" );
@@ -37,9 +38,28 @@ KinectContext::~KinectContext(void)
   close();
 }
 
+void KinectContext::addInstance(void)
+{
+  m_instances++;
+  if ( m_instances == 1 ) {
+    pthread_create( &m_thread, NULL, staticThreadFunc, this );
+  };
+}
+
+void KinectContext::removeInstance(void)
+{
+  m_instances--;
+  if ( m_instances == 0 ) {
+    pthread_cond_wait( &m_cond, &m_mutex );
+  }
+}
+
 void KinectContext::close(void)
 {
   if ( m_context != NULL ) {
+    pthread_join( m_thread, NULL );
+    pthread_mutex_destroy( &m_mutex );
+    pthread_cond_destroy( &m_cond );
     freenect_shutdown( m_context );
     m_context = NULL;
   };
@@ -52,6 +72,21 @@ freenect_context *KinectContext::get(void) throw (Error)
   return m_context;
 }
 
+void KinectContext::lock(void)
+{
+  pthread_mutex_lock( &m_mutex );
+}
+
+void KinectContext::wait(void)
+{
+  processEvents();
+}
+
+void KinectContext::unlock(void)
+{
+  pthread_mutex_unlock( &m_mutex );
+}
+
 void KinectContext::processEvents(void) throw (Error)
 {
   ERRORMACRO( freenect_process_events( m_context ) >= 0, Error, , "Error processing "
@@ -65,6 +100,27 @@ string KinectContext::inspect(void) const
   return s.str();
 }
 
+void KinectContext::threadFunc(void)
+{
+  bool quit = false;
+  while ( !quit ) {
+    lock();
+    if ( m_instances > 0 )
+      processEvents();
+    else {
+      pthread_cond_signal( &m_cond );
+      quit = true;
+    };
+    unlock();
+  };
+}
+
+void *KinectContext::staticThreadFunc( void *self )
+{
+  ((KinectContext *)self)->threadFunc();
+  return self;
+}
+
 VALUE KinectContext::registerRubyClass( VALUE module )
 {
   cRubyClass = rb_define_class_under( module, "KinectContext", rb_cObject );

data/ext/kinectcontext.hh

@@ -28,15 +28,26 @@ public:
   virtual ~KinectContext(void);
   std::string inspect(void) const;
   void close(void);
+  void addInstance(void);
+  void removeInstance(void);
   void processEvents(void) throw (Error);
   freenect_context *get(void) throw (Error);
+  void lock(void);
+  void wait(void);
+  void unlock(void);
   static VALUE cRubyClass;
   static VALUE registerRubyClass( VALUE module );
   static void deleteRubyObject( void *ptr );
   static VALUE wrapNew( VALUE rbClass );
   static VALUE wrapClose( VALUE rbSelf );
 protected:
+  void threadFunc(void);
+  static void *staticThreadFunc( void *self );
   freenect_context *m_context;
+  pthread_t m_thread;
+  pthread_mutex_t m_mutex;
+  pthread_cond_t m_cond;
+  int m_instances;
 };
   
 typedef boost::shared_ptr< KinectContext > KinectContextPtr;

data/ext/kinectinput.cc

@@ -25,13 +25,16 @@ KinectInput::KinectInput( KinectContextPtr context, int node ) throw (Error):
   m_context( context ), m_node( node ), m_device( NULL ), m_currentRGB(0), m_haveRGB(false),
   m_currentDepth(0), m_haveDepth(false)
 {
-  m_rgb[0] = NULL; m_rgb[1] = NULL; m_depth[0] = NULL; m_depth[1] = NULL;
-  ERRORMACRO( freenect_open_device( context->get(), &m_device, node ) >= 0, Error, ,
-              "Failed to open Kinect device number " << node );
-  m_rgb[0] = (char *)malloc( FREENECT_VIDEO_RGB_SIZE );
-  m_rgb[1] = (char *)malloc( FREENECT_VIDEO_RGB_SIZE );
-  m_depth[0] = (char *)malloc( FREENECT_DEPTH_11BIT_SIZE );
-  m_depth[1] = (char *)malloc( FREENECT_DEPTH_11BIT_SIZE );
+  memset( &m_rgb, 0, sizeof(m_rgb) ); memset( &m_depth, 0, sizeof(m_depth) );
+  m_context->lock();
+  if ( freenect_open_device( context->get(), &m_device, node ) < 0 ) {
+    m_context->unlock();
+    ERRORMACRO( false, Error, , "Failed to open Kinect device number " << node );
+  };
+  for ( int i=0; i<3; i++ ) {
+    m_rgb[i] = (char *)malloc( FREENECT_VIDEO_RGB_SIZE );
+    m_depth[i] = (char *)malloc( FREENECT_DEPTH_11BIT_SIZE );
+  };
   instances[ m_device ] = this;
   freenect_set_depth_format( m_device, FREENECT_DEPTH_11BIT );
   freenect_set_video_format( m_device, FREENECT_VIDEO_RGB );
@@ -41,6 +44,8 @@ KinectInput::KinectInput( KinectContextPtr context, int node ) throw (Error):
   freenect_set_video_callback( m_device, staticVideoCallBack );
   freenect_start_depth( m_device );
   freenect_start_video( m_device );
+  m_context->addInstance();
+  m_context->unlock();
 }
 
 KinectInput::~KinectInput(void)
@@ -51,29 +56,26 @@ KinectInput::~KinectInput(void)
 void KinectInput::close(void)
 {
   if ( m_device != NULL ) {
+    m_context->lock();
     freenect_stop_depth( m_device );
     freenect_stop_video( m_device );
     freenect_set_led( m_device, LED_BLINK_GREEN );
     freenect_close_device( m_device );
     instances.erase( m_device );
+    m_context->removeInstance();
+    m_context->unlock();
     m_context.reset();
     m_device = NULL;
   };
-  if ( m_depth[1] != NULL ) {
-    free( m_depth[1] );
-    m_depth[1] = NULL;
-  };
-  if ( m_depth[0] != NULL ) {
-    free( m_depth[0] );
-    m_depth[0] = NULL;
-  };
-  if ( m_rgb[1] != NULL ) {
-    free( m_rgb[1] );
-    m_rgb[1] = NULL;
-  };
-  if ( m_rgb[0] != NULL ) {
-    free( m_rgb[0] );
-    m_rgb[0] = NULL;
+  for ( int i=0; i<3; i++ ) {
+    if ( m_depth[i] != NULL ) {
+      free( m_depth[i] );
+      m_depth[i] = NULL;
+    };
+    if ( m_rgb[i] != NULL ) {
+      free( m_rgb[i] );
+      m_rgb[i] = NULL;
+    };
   };
   m_node = -1;
 }
@@ -82,11 +84,15 @@ FramePtr KinectInput::readVideo(void) throw (Error)
 {
   ERRORMACRO( m_device != NULL, Error, , "Kinect device is not open. "
               "Did you call \"close\" before?" );
-  while ( !m_haveRGB ) m_context->processEvents();
+  m_context->lock();
+  while ( !m_haveRGB ) m_context->wait();
   m_haveRGB = false;
+  char *data = m_rgb[ 2 ];
+  m_rgb[ 2 ] = m_rgb[ 1 - m_currentRGB ];
+  m_rgb[ 1 - m_currentRGB ] = data;
+  m_context->unlock();
   FramePtr retVal = FramePtr
-    ( new Frame( "UBYTERGB", FREENECT_FRAME_W, FREENECT_FRAME_H,
-                 m_rgb[ 1 - m_currentRGB ] ) );
+    ( new Frame( "UBYTERGB", FREENECT_FRAME_W, FREENECT_FRAME_H, m_rgb[ 2 ] ) );
   return retVal;
 }
 
@@ -94,11 +100,15 @@ FramePtr KinectInput::readDepth(void) throw (Error)
 {
   ERRORMACRO( m_device != NULL, Error, , "Kinect device is not open. "
               "Did you call \"close\" before?" );
-  while ( !m_haveDepth ) m_context->processEvents();
+  m_context->lock();
+  while ( !m_haveDepth ) m_context->wait();
   m_haveDepth = false;
+  char *data = m_depth[ 2 ];
+  m_depth[ 2 ] = m_depth[ 1 - m_currentDepth ];
+  m_depth[ 1 - m_currentDepth ] = data;
+  m_context->unlock();
   FramePtr retVal = FramePtr
-    ( new Frame( "USINT", FREENECT_FRAME_W, FREENECT_FRAME_H,
-                 m_depth[ 1 - m_currentDepth ] ) );
+    ( new Frame( "USINT", FREENECT_FRAME_W, FREENECT_FRAME_H, m_depth[ 2 ] ) );
   return retVal;
 }
 
@@ -118,16 +128,26 @@ void KinectInput::setLED( unsigned char state ) throw (Error)
 {
   ERRORMACRO( m_device != NULL, Error, , "Kinect device is not open. "
               "Did you call \"close\" before?" );
-  ERRORMACRO( freenect_set_led( m_device, (freenect_led_options)state ) == 0, Error, ,
-              "Error setting LED state" );
+  m_context->lock();
+  if ( freenect_set_led( m_device, (freenect_led_options)state ) == 0 ) {
+    m_context->unlock();
+  } else {
+    m_context->unlock();
+    ERRORMACRO( false, Error, , "Error setting LED state" );
+  };
 }
 
 void KinectInput::setTilt( double angle ) throw (Error)
 {
   ERRORMACRO( m_device != NULL, Error, , "Kinect device is not open. "
               "Did you call \"close\" before?" );
-  ERRORMACRO( freenect_set_tilt_degs( m_device, angle ) == 0, Error, ,
-              "Error setting tilt angle" );
+  m_context->lock();
+  if ( freenect_set_tilt_degs( m_device, angle ) == 0 ) {
+    m_context->unlock();
+  } else {
+    ERRORMACRO( false, Error, , "Error setting tilt angle" );
+    m_context->unlock();
+  };
 }
 
 void KinectInput::getState(void) throw (Error)

data/ext/kinectinput.hh

@@ -63,10 +63,10 @@ public:
   freenect_device *m_device;
   int m_currentRGB;
   bool m_haveRGB;
-  char *m_rgb[2];
+  char *m_rgb[3];
   int m_currentDepth;
   bool m_haveDepth;
-  char *m_depth[2];
+  char *m_depth[3];
 };
 
 typedef boost::shared_ptr< KinectInput > KinectInputPtr;

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Jan Wedekind
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-09 00:00:00 +00:00
+date: 2011-03-11 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency