ffi-libfreenect 0.1.1

data/History.txt

@@ -0,0 +1,5 @@
+== 0.1.1 / 2010-12-22
+* Initial release version
+
+== 0.1.0 / 2010-12-13
+* Initial packaged version

data/LICENSE.txt

@@ -0,0 +1,23 @@
+The MIT License
+
+Copyright (c) 2010 Josh Grunzweig & Eric Monti
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README.rdoc

@@ -0,0 +1,86 @@
+= ffi-libfreenect
+
+FFI-based Ruby wrapper for the OpenKinect libfreenect library.
+
+== Requirements
+  * ffi >= 0.5.0
+
+== Installation
+
+=== via Gem
+
+    (sudo)? gem install ffi-libfreenect
+
+=== via Rake
+
+    git clone http://github.com/jgrunzweig/ffi-libfreenect.git
+    cd ffi-libfreenect
+    (sudo)? gem install jeweler
+    rake install
+
+=== Synopsis
+
+    require 'freenect'
+
+    ctx = Freenect.init()
+    devs = ctx.num_devices
+
+    STDERR.puts "Number of Kinects detected: #{devs}"
+    unless devs > 0
+      STDERR.puts "Error: no kinect detected"
+      exit 1
+    end
+
+    STDERR.puts "Selecting device 0"
+    dev = ctx.open_device(0)
+
+    dev.set_led(:red)   # play with the led
+    dev.set_tilt_degrees(30)  # tilt up to max
+    sleep 1
+    dev.set_tilt_degrees(-30) # tilt down to max
+    sleep 1
+    dev.set_tilt_degrees(0.0) # tilt back to center
+    sleep 1
+    dev.set_led(:green)   # play with the led
+
+    # Actual video and depth capture work similarly to eachother.
+    # But they're still both pretty un-sugary.
+    #
+    # Future versions will probably abstract this and try to make it more 
+    # ruby-ish.
+    #
+    # The example below shows how to write a single video frame to a PPM file.
+
+    dev.set_depth_format(Freenect::DEPTH_11BIT)
+    dev.set_video_format(Freenect::VIDEO_RGB)
+    dev.start_depth()
+    dev.start_video()
+
+    $snapshot_finished = nil
+
+    STDERR.puts "Taking snapshot"
+    dev.set_video_callback do |device, video, timestamp|
+      if not $snapshot_finished
+        fname = "%u.ppm" % timestamp
+        STDERR.puts "Writing #{fname}"
+        File.open(fname, "w") do |f|
+          f.puts("P6 %d %d 255\n" % [ Freenect::FRAME_W, Freenect::FRAME_H ] )
+          f.write(video.read_string_length(Freenect::RGB_SIZE))
+        end
+        $snapshot_finished = true
+      end
+    end
+
+    until $snapshot_finished 
+      break if (ctx.process_events >= 0)
+    end
+
+    dev.set_led(:off)
+    dev.stop_depth
+    dev.stop_video
+    dev.close
+    ctx.close
+
+== Copyright
+
+Copyright (c) 2010 Josh Grunzweig & Eric Monti. See LICENSE.txt for details.

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "ffi-libfreenect"
+    gem.summary = gem.description = %Q{FFI bindings for the libfreenect OpenKinect library}
+    gem.homepage = "http://github.com/jgrunzweig/ffi-libfreenect"
+    gem.authors = ["Josh Grunzweig", "Eric Monti"]
+
+    gem.rdoc_options += ["--title", "FFI Freenect", "--main",  "README.rdoc", "--line-numbers"]
+    gem.add_dependency("ffi", ">= 0.5.0")
+
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yardoc do
+    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
+  end
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/examples/record.rb

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+# This is a more or less a straight ruby port of the "record" utility 
+# included in the libfreenect fakenect directory using the 
+# ffi-libfreenect ruby class wrappers. 
+#
+# This was really implemented just to see if ffi-libfreenect was working.
+# However, the output should be completely compatible the C version fakenect.
+#
+# usage: record.rb output_dir
+#
+
+begin
+  require 'rubygems'
+rescue LoadError
+end
+
+$: << File.expand_path(File.join(File.dirname(__FILE__), "../lib"))
+require 'freenect'
+
+$last_timestamp = 0
+$record_running = true
+
+def open_dump(type, timestamp, extension)
+  $last_timestamp = timestamp
+  filename = "%s-%f-%u.%s" % [ type, Time.now.to_f, timestamp, extension]
+  STDERR.puts "Writing: #{File.join($out_dir, filename)}"
+  File.open(File.join($out_dir,"INDEX.txt"), "a"){|f| f.puts(filename) }
+  File.open(File.join($out_dir, filename), "wb") {|f| yield f}
+end
+
+orig_dir = Dir.pwd
+unless $out_dir = ARGV.shift
+  STDERR.puts "usage: #{File.basename $0} output_dir"
+  exit 1
+end
+Dir.mkdir($out_dir) unless File.directory?($out_dir)
+
+trap('INT') do
+  STDERR.puts "Caught INT signal cleaning up"
+  $record_running = false
+end
+
+ctx = Freenect.init()
+dev = ctx.open_device(0)
+
+dev.set_depth_format(Freenect::DEPTH_11BIT)
+dev.set_video_format(Freenect::VIDEO_RGB)
+dev.start_depth()
+dev.start_video()
+
+dev.set_depth_callback do |device, depth, timestamp|
+  open_dump('d', timestamp, "pgm") do |f|
+    f.puts("P5 %d %d 65535\n" % [ Freenect::FRAME_W, Freenect::FRAME_H ] )
+    f.write(depth.read_string_length(Freenect::DEPTH_11BIT_SIZE))
+  end
+end
+
+dev.set_video_callback do |device, video, timestamp|
+  open_dump('r', timestamp, 'ppm') do |f|
+    f.puts("P6 %d %d 255\n" % [ Freenect::FRAME_W, Freenect::FRAME_H ] )
+    f.write(video.read_string_length(Freenect::RGB_SIZE))
+  end
+end
+
+while $record_running and (ctx.process_events >= 0)
+  open_dump('a', $last_timestamp, "dump") do |f|
+    state = dev.get_tilt_state
+    f.write(state.to_ptr.read_string_length(state.size))
+  end
+end
+
+Dir.chdir(orig_dir)
+dev.stop_depth
+dev.stop_video
+dev.close
+ctx.close

data/examples/tilt_led.rb

@@ -0,0 +1,105 @@
+class TILT_LED
+
+  def initialize
+    $: << File.expand_path(File.join(File.dirname(__FILE__), '../lib'))
+    require 'freenect'
+    check_args
+    initialize_device
+    tilt_led_set
+    cleanup
+  end
+
+  #
+  # Define usage
+  #
+  def script_usage
+    puts "Usage: ruby tilt_led.rb -l (0-6) -t (-30-30)"
+    puts "LED Options:"
+    puts "   0 - Off"
+    puts "   1 - Green"
+    puts "   2 - Red"
+    puts "   3 - Yellow"
+    puts "   4 - Blink Yellow"
+    puts "   5 - Blink Green"
+    puts "   6 - Blink Red/Yellow"
+    puts "Tilt Options:"
+    puts "   Value must be between -30 and 30 degrees."
+    exit 1
+  end
+
+  #
+  # Check arguments. I'm sure there's a better way to do this. What can I saw, I'm a noob.
+  #
+  def check_args
+    if( ARGV.include?("-l") ||  ARGV.include?("-t") )
+      if (ARGV.include?("-l"))
+        @led_option = ARGV[(ARGV.index("-l") + 1 )]
+        ARGV.delete("-l")
+        ARGV.delete(@led_option)
+        if @led_option.to_i < 0 || @led_option.to_i > 6
+          script_usage
+        end
+      end
+      if (ARGV.include?("-t"))
+        @tilt_option = ARGV[(ARGV.index("-t") + 1 )]
+        ARGV.delete("-t")
+        ARGV.delete(@tilt_option)
+        if @tilt_option.to_i < -30 || @tilt_option.to_i > 30
+          script_usage
+        end
+      end
+    else
+      script_usage
+    end
+  end
+  
+  def initialize_device
+    @ctx = FFI::MemoryPointer.new(:pointer)
+    @dev = FFI::MemoryPointer.new(:pointer)
+    #
+    # initialize context / @device
+    #
+    if (FFI::Freenect.freenect_init(@ctx,nil) != 0)
+        puts "Error: can't initialize context"
+        exit 1
+    end
+    @ctx = @ctx.read_pointer
+
+    if (FFI::Freenect.freenect_open_device(@ctx, @dev, 0) != 0)
+      puts "Error: can't initialize device"
+      exit 1
+    end
+    @dev = @dev.read_pointer
+  end
+  
+  def tilt_led_set
+    #
+    # Set tilt and/or led options on the @device
+    #
+    puts "Number of devices: #{FFI::Freenect.freenect_num_devices(@ctx)}"
+    if (not @tilt_option.nil?)
+      puts "Tilt set to: #{@tilt_option}"
+      FFI::Freenect.freenect_set_tilt_degs(@dev, @tilt_option.to_f)
+    end
+    if (not @led_option.nil?)
+      puts "LED set to: #{@led_option}"
+      FFI::Freenect.freenect_set_led(@dev, @led_option.to_i)
+    end
+  end
+
+  def cleanup
+    #
+    # Close the context and @device (for cleanup purposes)
+    #
+    FFI::Freenect.freenect_close_device(@dev)
+    if FFI::Freenect.freenect_shutdown(@ctx) != 0
+      puts "Error shutting down context"
+      exit 1
+    else
+      puts "Successfully shut down context"
+      exit 0
+    end
+  end
+end
+
+run = TILT_LED.new

data/examples/tilt_nod.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+#
+
+$: << File.expand_path(File.join(File.dirname(__FILE__), "../lib"))
+
+require 'freenect'
+
+ctx = Freenect.init
+unless ctx.num_devices() > 0
+  STDERR.puts "No kinect device detected"
+  exit 1
+end
+
+dev = ctx[0]
+dev.set_led(:blink_red_yellow)
+
+3.times do
+  dev.set_tilt_degrees(15)
+  sleep 2
+  dev.set_tilt_degrees(-15)
+  sleep 2
+end
+dev.set_tilt_degrees(0.0)
+
+dev.set_led(:off)
+dev.close
+ctx.shutdown
+

data/examples/video_snapshot.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+# Actual video and depth capture work similarly to eachother.
+# But they're still both pretty un-sugary.
+#
+# Future versions will probably abstract this and try to make it more 
+# ruby-ish.
+#
+# The example below shows how to capture a single video frame to a PPM file.
+
+$: << File.expand_path(File.join(File.dirname(__FILE__), "../lib"))
+require 'freenect'
+ctx = Freenect.init()
+
+devs = ctx.num_devices
+
+STDERR.puts "Number of Kinects detected: #{devs}"
+unless devs > 0
+  STDERR.puts "Error: no kinect detected"
+  exit 1
+end
+
+STDERR.puts "Selecting device 0"
+dev = ctx.open_device(0)
+
+dev.set_led(:green)   # play with the led
+
+dev.set_video_format(Freenect::VIDEO_RGB)
+dev.start_depth()
+dev.start_video()
+
+$snapshot_finished = nil
+
+STDERR.puts "Attempting snapshot"
+dev.set_video_callback do |device, video, timestamp|
+  if not $snapshot_finished
+    fname = "%i.ppm" % timestamp
+    STDERR.puts "Writing #{fname}"
+    File.open(fname, "w") do |f|
+      f.puts("P6 %d %d 255\n" % [ Freenect::FRAME_W, Freenect::FRAME_H ] )
+      f.write(video.read_string_length(Freenect::RGB_SIZE))
+    end
+    $snapshot_finished = true
+  end
+end
+
+ret = -1
+until $snapshot_finished 
+  break if (ret=ctx.process_events) >= 0
+end
+
+if ret < 0
+  STDERR.puts "Error: unable to take snapshot. process_events code=#{ret}"
+end
+
+dev.set_led(:off)
+dev.stop_depth
+dev.stop_video
+dev.close
+ctx.close
+
+

data/lib/ffi/freenect.rb

@@ -0,0 +1,170 @@
+begin
+  require 'rubygems'
+rescue LoadError
+  #nop
+end
+
+require 'ffi'
+
+module FFI::Freenect
+  extend FFI::Library
+  ffi_lib 'freenect', 'freenect_sync'
+  
+  FRAME_W = 640
+  FRAME_H = 480
+  FRAME_PIX = FRAME_W * FRAME_H
+
+  IR_FRAME_W = 640
+  IR_FRAME_H = 488
+  IR_FRAME_PIX = FRAME_W * FRAME_H
+ 
+  RGB_SIZE = FRAME_PIX * 3
+  BAYER_SIZE = FRAME_PIX
+  YUV_RGB_SIZE = RGB_SIZE
+  YUV_RAW_SIZE = FRAME_PIX * 2
+  IR_8BIT_SIZE = IR_FRAME_PIX
+  IR_10BIT_SIZE = IR_FRAME_PIX * 2
+  IR_10BIT_PACKED_SIZE = 390400
+
+  DEPTH_11BIT_SIZE = FRAME_PIX * 2
+  DEPTH_10BIT_SIZE = DEPTH_11BIT_SIZE
+  DEPTH_11BIT_PACKED_SIZE = 422400
+  DEPTH_10BIT_PACKED_SIZE = 384000
+
+  COUNTS_PER_G = 819
+
+	LED_OFF    = 0
+	LED_GREEN  = 1
+	LED_RED    = 2
+	LED_YELLOW = 3
+	LED_BLINK_YELLOW = 4
+	LED_BLINK_GREEN = 5
+	LED_BLINK_RED_YELLOW = 6
+
+  LED_OPTIONS = enum( :off,               LED_OFF,
+                      :green,             LED_GREEN,
+                      :red,               LED_RED,
+                      :yellow,            LED_YELLOW,
+                      :blink_yellow,      LED_BLINK_YELLOW,
+                      :blink_green,       LED_BLINK_GREEN,
+                      :blink_red_yellow,  LED_BLINK_RED_YELLOW) 
+ 
+ 
+	VIDEO_RGB = 0
+	VIDEO_BAYER = 1
+	VIDEO_IR_8BIT = 2
+	VIDEO_IR_10BIT = 3
+	VIDEO_IR_10BIT_PACKED = 4
+	VIDEO_YUV_RGB = 5
+	VIDEO_YUV_RAW = 6
+
+  VIDEO_FORMATS = enum( :rgb,             VIDEO_RGB,
+                        :bayer,           VIDEO_BAYER,
+                        :ir_8bit,         VIDEO_IR_8BIT,
+                        :ir_10bit,        VIDEO_IR_10BIT,
+                        :yuv_rgb,         VIDEO_YUV_RGB,
+                        :yuv_raw,         VIDEO_YUV_RAW,
+                        :ir_10bit_packed, VIDEO_IR_10BIT_PACKED)
+  
+  VIDEO_SIZES = enum( :rgb,             RGB_SIZE,
+                      :bayer,           BAYER_SIZE,
+                      :ir_8bit,         IR_8BIT_SIZE,
+                      :ir_10bit,        IR_10BIT_SIZE,
+                      :yuv_rgb,         YUV_RGB_SIZE,
+                      :yuv_raw,         YUV_RAW_SIZE,
+                      :ir_10bit_packed, IR_10BIT_PACKED_SIZE )
+
+ 
+	DEPTH_11BIT = 0
+	DEPTH_10BIT = 1
+	DEPTH_11BIT_PACKED = 2
+	DEPTH_10BIT_PACKED = 3
+
+  DEPTH_FORMATS = enum( :depth_11bit,         DEPTH_11BIT,
+                        :depth_10bit,         DEPTH_10BIT,
+                        :depth_11bit_packed,  DEPTH_11BIT_PACKED,
+                        :depth_10bit_packed,  DEPTH_10BIT_PACKED)
+
+  DEPTH_SIZES = enum( :depth_11bit,         DEPTH_11BIT_SIZE,
+                      :depth_10bit,         DEPTH_10BIT_SIZE,
+                      :depth_11bit_packed,  DEPTH_11BIT_PACKED_SIZE,
+                      :depth_10bit_packed,  DEPTH_10BIT_PACKED_SIZE )
+
+	TILT_STATUS_STOPPED = 0x00
+	TILT_STATUS_LIMIT = 0x01
+	TILT_STATUS_MOVING = 0x04
+
+  TILT_STATUS_CODES = enum( :stopped,  TILT_STATUS_STOPPED,
+                            :limit,    TILT_STATUS_LIMIT,
+                            :moving,   TILT_STATUS_MOVING)
+
+ 
+	LOG_FATAL = 0
+	LOG_ERROR = 1
+	LOG_WARNING = 2 
+	LOG_NOTICE = 3
+	LOG_INFO = 4
+	LOG_DEBUG = 5
+	LOG_SPEW = 6
+	LOG_FLOOD = 7
+
+  LOGLEVELS = enum( :fatal,   LOG_FATAL,
+                    :error,   LOG_ERROR,
+                    :warning, LOG_WARNING,
+                    :notice,  LOG_NOTICE,
+                    :info,    LOG_INFO,
+                    :debug,   LOG_DEBUG,
+                    :spew,    LOG_SPEW,
+                    :flood,   LOG_FLOOD)
+  
+  typedef :pointer, :freenect_context
+  typedef :pointer, :freenect_device
+  typedef :pointer, :freenect_usb_context # actually a libusb_context
+ 
+ 
+  class RawTiltState < FFI::Struct
+    layout :accelerometer_x,  :int16_t,
+           :accelerometer_y,  :int16_t,
+           :accelerometer_z,  :int16_t, 
+           :tilt_angle,       :int8_t, 
+           :tilt_status,      TILT_STATUS_CODES
+  end
+
+  callback :freenect_log_cb, [:freenect_context, LOGLEVELS, :string], :void
+  callback :freenect_depth_cb, [:freenect_device, :pointer, :uint32], :void
+  callback :freenect_video_cb, [:freenect_device, :pointer, :uint32], :void
+
+  attach_function :freenect_set_log_level, [:freenect_context, LOGLEVELS], :void
+  attach_function :freenect_set_log_callback, [:freenect_context, :freenect_log_cb], :void
+  attach_function :freenect_process_events, [:freenect_context], :int
+  attach_function :freenect_num_devices, [:freenect_context], :int
+  attach_function :freenect_open_device, [:freenect_context, :freenect_device, :int], :int
+  attach_function :freenect_close_device, [:freenect_device], :int
+  attach_function :freenect_init, [:freenect_context, :freenect_usb_context], :int
+  attach_function :freenect_shutdown, [:freenect_context], :int
+  attach_function :freenect_set_user, [:freenect_device, :pointer], :void
+  attach_function :freenect_get_user, [:freenect_device], :pointer
+  attach_function :freenect_set_depth_callback, [:freenect_device, :freenect_depth_cb], :void
+  attach_function :freenect_set_video_callback, [:freenect_device, :freenect_video_cb], :void  
+  attach_function :freenect_set_depth_format, [:freenect_device, DEPTH_FORMATS], :int
+  attach_function :freenect_set_video_format, [:freenect_device, VIDEO_FORMATS], :int
+  attach_function :freenect_set_depth_buffer, [:freenect_device, :void], :int
+  attach_function :freenect_set_video_buffer, [:freenect_device, :void], :int
+  attach_function :freenect_start_depth, [:freenect_device], :int
+  attach_function :freenect_start_video, [:freenect_device], :int
+  attach_function :freenect_stop_depth, [:freenect_device], :int
+  attach_function :freenect_stop_video, [:freenect_device], :int
+  attach_function :freenect_update_tilt_state, [:freenect_device], :int
+  attach_function :freenect_get_tilt_state, [:freenect_device], RawTiltState
+  attach_function :freenect_get_tilt_degs, [:freenect_device], :double
+  attach_function :freenect_set_tilt_degs, [:freenect_device, :double], :int
+  attach_function :freenect_set_led, [:freenect_device, LED_OPTIONS], :int
+  attach_function :freenect_get_mks_accel, [RawTiltState, :pointer, :pointer, :pointer], :void
+
+  attach_function :freenect_sync_get_video, [:pointer, :pointer, :int, VIDEO_FORMATS], :int
+  attach_function :freenect_sync_get_depth, [:pointer, :pointer, :int, DEPTH_FORMATS], :int
+  attach_function :freenect_sync_stop, [], :void
+
+end
+
+