nl-knd_client 0.0.0.pre.usegit

data/lib/nl/knd_client/em_knd_command.rb

@@ -0,0 +1,77 @@
+module NL
+  module KndClient
+    # Represents a deferred KND command run by the EventMachine-based client,
+    # EMKndClient.  Callbacks will be called with the EMKndCommand object as
+    # their sole parameter.
+    class EMKndCommand
+      include EM::Deferrable
+      attr_reader :linecount, :lines, :name, :message
+
+      # Initializes a deferred 'name' command, removing commas from arguments
+      # (KND command arguments cannot contain commas)
+      def initialize(name, *args)
+        @name = name
+        @args = args
+        @argstring = (args.length > 0 && " #{@args.map {|s| s.to_s.gsub(',', '') if s != nil }.join(',')}") || ''
+        @linecount = 0
+        @lines = []
+        @message = ""
+
+        timeout 10
+
+        log "Command #{@name} Initialized" if EMKndClient.debug_cmd?(@name)
+      end
+
+      # Called by EMKndClient when a success line is received
+      # Returns true if the command is done, false if lines are needed
+      def ok_line(message)
+        @message = message
+
+        log "Command #{@name} OK - #{message}" if EMKndClient.debug_cmd?(@name)
+
+        case @name
+        when "zones", "help"
+          @linecount = message.to_i
+        end
+
+        if @linecount == 0
+          succeed self
+          return true
+        end
+
+        return false
+      end
+
+      # Called by EMKndClient when an error line is received
+      def err_line(message)
+        @message = message
+
+        log "Command #{@name} ERR - #{message}" if EMKndClient.debug_cmd?(@name)
+
+        fail self
+      end
+
+      # Called by EMKndClient to add a line
+      # Returns true when enough lines have been received
+      def add_line(line)
+        lines << line
+        @linecount -= 1
+        if @linecount == 0
+          succeed self
+        end
+        return @linecount == 0
+      end
+
+      # Converts the command to a string formatted for sending to knd.
+      def to_s
+        "#{@name}#{@argstring}"
+      end
+
+      private
+
+      def log(msg)
+        EMKndClient.log(msg)
+      end
+    end
+  end
+end

data/lib/nl/knd_client/simple_knd_client.rb

@@ -0,0 +1,106 @@
+require 'socket'
+
+module NL
+  module KndClient
+    # A simple KND client that uses a background thread for I/O and works
+    # without EventMachine.  This client does not (yet) support all of KND's
+    # features.
+    class SimpleKndClient
+      def initialize(host: 'localhost', port: 14308)
+        @host = host
+        @port = 14308
+
+        @callbacks = {}
+        @zones = {}
+      end
+
+      # Calls the given block with the current full state of a zone, the type of
+      # command received for a zone, and the updates for the zone.  '! DEPTH' is a
+      # special zone name for depth images [HACK].
+      def on_zone(name, &block)
+        @callbacks[name] ||= []
+        @callbacks[name] << block
+      end
+
+      # Removes the given callback from the given zone name.  '! DEPTH' is a
+      # special zone name for depth images [HACK].
+      def remove_callback(name, &block)
+        @callbacks[name]&.delete(block)
+      end
+
+      # Connect to KND.
+      def open
+        @socket = TCPSocket.new(@host, @port)
+        @run = true
+        @t = Thread.new do read_loop end
+        @socket.puts('sub')
+      end
+
+      # Close the connection to KND and stop the background thread.
+      def close
+        @run = false
+        @t&.wakeup
+        @t&.kill
+        @socket&.close
+        @t = nil
+        @socket = nil
+      end
+
+      # Waits for and then returns depth data.
+      def get_depth
+        data = nil
+        t = Thread.current
+
+        cb = ->(d) { data = d; t.wakeup }
+        on_zone('! DEPTH', &cb)
+
+        @socket.puts('getdepth')
+        sleep(1)
+
+        raise "Data wasn't set within 1 second" if data.nil?
+
+        data
+      ensure
+        remove_callback('! DEPTH', &cb)
+      end
+
+      private
+
+      def read_loop
+        while @run do
+          line = @socket.readline
+
+          begin
+            type = line.split(' - ', 2).first
+
+            case type
+            when 'DEL', 'OK'
+              next
+
+            when 'DEPTH'
+              num_bytes = line.gsub(/\A[^0-9]*(\d+)[^0-9]*\z/, '\1').to_i
+              puts "\n\n\n\n\e[1;33m=========== DEPTH line #{num_bytes} ============\n\n\n\n"
+              data = @socket.read(num_bytes)
+              @callbacks['! DEPTH']&.each do |cb|
+                cb.call(data) rescue puts "Error calling depth callback: #{MB::Sound::U.syntax($!.inspect)}"
+              end
+
+            else
+              kvp = line.kin_kvp(symbolize_keys: true)
+              name = kvp[:name] || (raise "No zone name was found")
+              @zones[name] ||= {}
+              @zones[name].merge!(kvp)
+
+              @callbacks[kvp[:name]]&.each do |cb|
+                cb.call(@zones[name]) rescue puts "Error calling callback: #{MB::Sound::U.syntax($!)}\n\t#{MB::Sound::U.syntax($!.backtrace.join("\n\t"))}"
+              end
+            end
+
+          rescue => e
+            puts "Error parsing line '#{line}': #{MB::Sound::U.syntax(e)}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nl/knd_client/version.rb

@@ -0,0 +1,5 @@
+module NL
+  module KndClient
+    VERSION = "0.0.0-usegit"
+  end
+end

data/lib/nl/knd_client/zone.rb

@@ -0,0 +1,227 @@
+module NL
+  module KndClient
+    # Represents a spatial zone from KND.
+    class Zone < Hash
+      # Switched to integer millimeters in version 2
+      ZONE_VERSION = 2
+
+      # TODO: This should be a constant, not a class variable
+      @@param_names = {
+        'occupied' => 'Occupied',
+
+        'bright' => 'Brightness',
+
+        'sa' => 'Surface Area',
+
+        'xc' => 'X Center',
+        'yc' => 'Y Center',
+        'zc' => 'Z Center',
+
+        'xmin' => 'World Xmin',
+        'ymin' => 'World Ymin',
+        'zmin' => 'World Zmin',
+        'xmax' => 'World Xmax',
+        'ymax' => 'World Ymax',
+        'zmax' => 'World Zmax',
+
+        'px_xmin' => 'Screen Xmin',
+        'px_ymin' => 'Screen Ymin',
+        'px_zmin' => 'Screen Zmin',
+        'px_xmax' => 'Screen Xmax',
+        'px_ymax' => 'Screen Ymax',
+        'px_zmax' => 'Screen Zmax',
+
+        'pop' => 'Population',
+        'maxpop' => 'Max Population',
+
+        'negate' => 'Inverted',
+        'param' => 'Occupied Parameter',
+        'on_level' => 'Rising Threshold',
+        'off_level' => 'Falling Threshold',
+        'on_delay' => 'Rising Delay',
+        'off_delay' => 'Falling Delay',
+      }.freeze
+
+      @@name_params = @@param_names.invert.freeze
+
+      # Merges with the other Hash or Zone, then converts known keys into
+      # their expected types.
+      def merge_zone other
+        merge! other
+        normalize! unless other.is_a? Zone
+        self
+      end
+
+      # Initializes a zone definition with the given key-value set.  If
+      # kvpairs is a string, it is parsed with kin_kvp().  If it is a Hash,
+      # its keys are used as the zone definition.
+      def initialize kvpairs, normalize=true
+        EMKndClient.bench 'Zone.new' do
+          super nil
+          if kvpairs.is_a? String
+            EMKndClient.bench 'Zone.new string' do
+              merge! kvpairs.kin_kvp
+              normalize = false
+            end
+          elsif kvpairs.is_a? Hash
+            EMKndClient.bench 'Zone.new hash' do
+              merge! kvpairs
+            end
+          else
+            raise "kvpairs must be a String or a Hash, not #{kvpairs.class}."
+          end
+          normalize! if normalize
+          self['occupied'] = (self['occupied'] == 1) if self['occupied'].is_a?(Fixnum)
+        end
+      end
+
+      # Converts known keys into their expected types.
+      def normalize!
+        EMKndClient.bench 'Zone.normalize!' do
+          if has_key?('version') && self['version'].to_i < 2
+            EMKndClient.log "Converting version #{self['version']} zone to version #{ZONE_VERSION}"
+            self['xmin'] &&= self['xmin'].to_f * 1000.0
+            self['ymin'] &&= self['ymin'].to_f * 1000.0
+            self['zmin'] &&= self['zmin'].to_f * 1000.0
+            self['xmax'] &&= self['xmax'].to_f * 1000.0
+            self['ymax'] &&= self['ymax'].to_f * 1000.0
+            self['zmax'] &&= self['zmax'].to_f * 1000.0
+          end
+
+          self['xmin'] &&= self['xmin'].to_i
+          self['ymin'] &&= self['ymin'].to_i
+          self['zmin'] &&= self['zmin'].to_i
+          self['xmax'] &&= self['xmax'].to_i
+          self['ymax'] &&= self['ymax'].to_i
+          self['zmax'] &&= self['zmax'].to_i
+          self['px_xmin'] &&= self['px_xmin'].to_i
+          self['px_ymin'] &&= self['px_ymin'].to_i
+          self['px_zmin'] &&= self['px_zmin'].to_i
+          self['px_xmax'] &&= self['px_xmax'].to_i
+          self['px_ymax'] &&= self['px_ymax'].to_i
+          self['px_zmax'] &&= self['px_zmax'].to_i
+          self['pop'] &&= self['pop'].to_i
+          self['maxpop'] &&= self['maxpop'].to_i
+          self['xc'] &&= self['xc'].to_i
+          self['yc'] &&= self['yc'].to_i
+          self['zc'] &&= self['zc'].to_i
+          self['sa'] &&= self['sa'].to_i
+          self['bright'] &&= self['bright'].to_i
+
+          if has_key? 'negate'
+            if self['negate'] == 'true' then
+              self['negate'] = true
+            elsif self['negate'] == 'false' then
+              self['negate'] = false
+            elsif self['negate'].respond_to? 'to_i' then
+              self['negate'] = self['negate'].to_i == 1 ? true : false
+            else
+              self['negate'] = !!self['negate']
+            end
+          end
+
+          unless self.range('param').include?(self['param'])
+            self.delete 'param'
+          end
+
+          self['on_level'] &&= self['on_level'].to_i
+          self['off_level'] &&= self['off_level'].to_i
+          self['on_delay'] &&= self['on_delay'].to_i
+          self['off_delay'] &&= self['off_delay'].to_i
+
+          if has_key? 'occupied' and self['occupied'].respond_to? 'to_i' then
+            self['occupied'] = self['occupied'].to_i == 1 ? true : false
+          end
+
+          Zone.fix_name!(self['name']) if has_key? 'name'
+        end
+
+        self
+      end
+
+      # Computes the range for the given parameter.  Returns nil if param is
+      # not a valid zone parameter, the parameter's range is unknown, or the
+      # given parameter has no range.
+      #
+      # TODO: this should probably just be a constant Hash
+      def range param
+        case param
+        when 'xmin', 'xmax'
+          (-KNC_XMAX / 2)..(KNC_XMAX / 2)
+
+        when 'ymin', 'ymax'
+          (-KNC_YMAX / 2)..(KNC_YMAX / 2)
+
+        when 'zmin', 'zmax'
+          0..KNC_ZMAX
+
+        when 'px_xmin', 'px_xmax'
+          0..639
+
+        when 'px_ymin', 'px_ymax'
+          0..479
+
+        when 'px_zmin', 'px_zmax'
+          0..KNC_PXZMAX
+
+        when 'pop'
+          0..self['maxpop']
+
+        when 'maxpop'
+          0..(640 * 480)
+
+        when 'xc'
+          0..1000
+
+        when 'yc'
+          0..1000
+
+        when 'zc'
+          0..1000
+
+        when 'sa'
+          (self['xmax'] - self['xmin']) * (self['ymax'] - self['ymin'])
+
+        when 'bright'
+          0..1000
+
+        when 'negate'
+          [false, true]
+
+        when 'param'
+          ['pop', 'sa', 'bright', 'xc', 'yc', 'zc']
+
+        when 'on_level', 'off_level'
+          # TODO: Range depends on param
+          -5000..(640 * 480)
+
+        when 'on_delay', 'off_delay'
+          0..(86400 * 30)
+
+        else
+          nil
+        end
+      end
+
+      # Returns a hash mapping parameter names to their human-friendly names
+      # (excludes the 'name' parameter).
+      def self.params
+        @@param_names
+      end
+
+      # Returns a hash mapping human-friendly names to parameter names.
+      def self.names
+        @@name_params
+      end
+
+      # Removes unsupported characters from the given name, modifying the string directly
+      def self.fix_name! str
+        # TODO: Support spaces (need to change HTML to use data-zone),
+        # strip or error on non-UTF8 non-printable characters
+        str.delete!(",")
+        str.tr!(" \t\r\n", '_')
+        str
+      end
+    end
+  end
+end

data/nl-knd_client.gemspec

@@ -0,0 +1,37 @@
+require_relative 'lib/nl/knd_client/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "nl-knd_client"
+  spec.version       = NL::KndClient::VERSION
+  spec.authors       = ["Mike Bourgeous"]
+  spec.email         = ["mike@mikebourgeous.com"]
+
+  spec.summary       = %q{Client library for Nitrogen Logic's Kinect data server, KND (use Git directly for installation)}
+  spec.homepage      = "https://github.com/nitrogenlogic/nl-knd_client"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.license = 'AGPLv3'
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.extensions = [
+    'ext/kinutils/extconf.rb'
+  ]
+
+  spec.add_runtime_dependency 'nl-fast_png'
+
+  spec.add_development_dependency 'rake-compiler'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'eventmachine'
+end