bvh 1.0.0

data/lib/bvh/motion/frame.rb

@@ -0,0 +1,124 @@
+class Bvh
+  class Motion
+
+    class Frame
+      # The array of ChannelData objects for this frame: one ChannelData instance for each bone.
+      attr_reader :channel_data
+
+      def initialize()
+        @channel_data = []
+      end
+
+      # Creates a copy of this frame, including a dup of its channel data.
+      def copy
+        ret = self.class.new
+        channel_data.each do |datum|
+          ret.channel_data << datum.dup
+        end
+        ret
+      end
+
+      # call-seq:
+      #   frame + frame  => new_frame
+      #   frame - frame  => new_frame
+      #   frame / frame  => new_frame
+      #   frame * frame  => new_frame
+      #   frame + number => new_frame
+      #   frame - number => new_frame
+      #   frame / number => new_frame
+      #   frame * number => new_frame
+      #
+      # Performs arithmetic on this frame with the target. The second operand may be either a number or another Frame.
+      # If the target is a number, then that number is added to, subtracted from, multiplied with, or divided against
+      # each channel of each ChannelData object in this frame.
+      #
+      # If the target is another Frame, the arithmetic looks something like this (simplified):
+      #   return_value.channel_data[0] = frame1.channel_data[0] * frame2.channel_data[0]
+      #   return_value.channel_data[0] = frame1.channel_data[1] * frame2.channel_data[1]
+      #   return_value.channel_data[0] = frame1.channel_data[2] * frame2.channel_data[2]
+      #   . . .
+      #
+      # Both frames must contain the same number of ChannelData instances, and each instance must
+      # have the same number of channels, and each instance must also reference the same bone.
+      #
+      # Returns a new frame containing the result.
+      #
+      def arithmetic_proc(target)
+        # Fooled you! I metaprogrammed it to save some typing!
+      end
+      undef arithmetic_proc
+
+      [:+, :-, :/, :*].each do |operator|
+        define_method operator do |target|
+          if target.kind_of?(Frame)
+            unless channel_data.length == target.channel_data.length
+              raise "Expected both frames to have the same amount of data"
+            end
+            ret = Frame.new
+            channel_data.each_with_index do |datum, index|
+              ret.channel_data << datum.send(operator, target.channel_data[index])
+            end
+            ret
+          else
+            ret = Frame.new
+            channel_data.each { |datum| ret.channel_data << datum.send(operator, target) }
+          end
+          ret
+        end
+      end
+
+      # Returns the channel data for the specified bone.
+      def channel_data_for(bone)
+        @channel_data.each { |c| return c if c.bone == bone }
+        raise "Channel data for bone not found: #{bone.name}"
+      end
+
+      # Returns the relative, or local, transform matrix for the specified bone in this frame.
+      def relative_transform_matrix(bone)
+        return channel_data_for(bone).relative_transform_matrix
+      end
+
+      # Returns the transform matrix of the root node multiplied with its children recursively
+      # down to the specified bone, the result being the total transformation in worldspace for this frame.
+      def absolute_transform_matrix(bone)
+        relative = relative_transform_matrix(bone)
+        if bone.parent then absolute_transform_matrix(bone.parent) * relative
+        else relative
+        end
+      end
+
+      # Modifies a single attribute of the channel data for this bone in this frame. Returns self.
+      #
+      # Ex:
+      #   bvh.last_frame.set_channel bone, 'Xrotation', 180 # => sets the bone to a 180 deg rotation around the X-axis
+      def set_channel(bone, channel, theta)
+        channel_data_for(bone).set_channel(channel, theta)
+      end
+
+      # Retrives the value for a specific channel for a specific bone within this frame.
+      def get_channel(bone, channel)
+        channel_data_for(bone).get_channel(channel)
+      end
+
+      # Modifies the channel data for this bone in this frame, resulting in a rotation around the specified
+      # channel.
+      #
+      # Ex:
+      #   bvh.last_frame.set_channel bone, 'Xrotation', 180 # => rotates the bone by 180 deg rotation around the X-axis
+      def rotate!(bone, channel, theta)
+        set_channel(bone, channel, channel_data_for(bone).get_channel(channel) + theta)
+      end
+
+      # Adds x, y and z to the X, Y and Z position channels for this bone in this frame, resulting in a "movement" or
+      # translation.
+      def translate!(bone, x, y, z)
+        set_channel(bone, 'Xposition', channel_data_for(bone).get_channel('Xposition')+x)
+        set_channel(bone, 'Yposition', channel_data_for(bone).get_channel('Yposition')+y)
+        set_channel(bone, 'Zposition', channel_data_for(bone).get_channel('Zposition')+z)
+      end
+
+      alias transform_matrix absolute_transform_matrix
+      alias local_transform_matrix relative_transform_matrix
+    end
+  end
+end

data/lib/bvh/parser.rb

@@ -0,0 +1,177 @@
+class Bvh
+  class Parser
+    attr_reader :filename
+    attr_reader :source
+
+    def initialize(file)
+      @filename = file
+      @source = File.read(file)
+    end
+
+    def parse(bvh)
+      @bvh = bvh
+
+      # a little touch-up...
+      s = source
+      # it's tempting to just downcase the whole string, but that'd change the case of object names, which might be
+      # bad for the end user. So we'll swap out specific keywords instead.
+      s.gsub!(/^((\s*)(root|offset|channels|joint|end site|hierarchy)(([^\n\{]*)(\n|\{)))/mi) do
+        match = $~
+        "#{match[2]}#{match[3].downcase.gsub(/\s/, '_')} \"#{match[5].strip}\"#{match[6]}"
+      end
+      # make { . . . } into proper Ruby blocks
+      s.gsub!(/[\n\s]*\{/m, ' do').gsub!(/[\n\s]*\}/m, "\nend")
+
+      # Finally, handle the MOTION segment, which can be treated as a single method call.
+      s.gsub!(/^((\s*)(motion)(.*))/mi) do
+        "#{$~[2]}#{$~[3].downcase} <<-EOF\n#{$~[4].strip}\nEOF\n"
+      end
+
+      eval(s, binding, @filename, 1)
+    end
+
+    private
+    attr_reader :bvh, :mode, :current_node
+
+    def bone(type, name, &block)
+      raise ArgumentError, "#{type} #{name} is unexpected at this time" unless mode == :hierarchy
+      bone = type.new(name)
+
+      if current_node.nil?
+        bvh.create_skeleton!.root = bone
+      else
+        current_node.add_joint!(bone)
+      end
+      
+      @current_node, bone = bone, @current_node
+      instance_eval(&block)
+      @current_node = bone
+    end
+
+    # Ex:
+    #   root "joint-pelvis" do
+    #     offset "0.00  0.00  0.00"
+    #     channels "6 Xposition Ypoisition Zposition Zrotation Xrotation Yrotation"
+    #     joint "joint-spine3" do
+    #       . . .
+    #     end
+    #   end
+    def root(name, &block)
+      @current_node = nil
+      bone Bvh::Skeleton::Bone, name, &block
+    end
+
+    # Ex:
+    #   root "joint-pelvis" do
+    #     . . .
+    #     joint "joint-spine3" do
+    #       offset "0.00  -10.65  0.00"
+    #       channels "3 Zrotation Xrotation Yrotation"
+    #       end_site do
+    #         . . .
+    #       end
+    #     end
+    #   end
+    def joint(name, &block)
+      bone Bvh::Skeleton::Bone, name, &block
+    end
+
+    # Ex:
+    #   root "joint-pelvis" do
+    #     . . .
+    #     joint "joint-spine3" do
+    #       . . .
+    #       end_site do
+    #         offset "0.00  -7.00  0.00"
+    #       end
+    #     end
+    #   end
+    def end_site(*unused, &block)
+      bone Bvh::Skeleton::Bone, nil, &block
+    end
+
+    def hierarchy(*unused)
+      @mode = :hierarchy
+    end
+
+    def offset(val)
+      raise ArgumentError, "OFFSET is unexpected at this time" unless current_node
+      raise ArgumentError, "Already have OFFSET data for this node" unless current_node.offset.length == 0
+      current_node.offset.concat val.split.collect { |i| i.to_f }
+    end
+
+    def channels(val)
+      raise ArgumentError, "CHANNELS is unexpected at this time" unless current_node
+      raise ArgumentError, "Already have CHANNELS data for this node" unless current_node.channels.length == 0
+      vals = val.split
+      count = vals.shift.to_i # how many?
+      raise ArgumentError, "Expected #{count} channels, found #{vals.length}" if vals.length != count
+      current_node.channels.concat vals
+    end
+
+    def motion(motion_data)
+      raise ArgumentError, "Motion data is unexpected at this time" unless mode == :hierarchy
+      @mode = :motion
+      frame_count = nil
+      motion_data.each_line do |line|
+        line = line.downcase.strip
+        words = line.split
+        case words.first
+          when 'frames:'
+            if words[1] =~ /[^0-9]/
+              raise ArgumentError, "Only one positive numeric integer value expected at this time (not #{words[1]})"
+            end
+            frame_count = words[1].to_i
+          when 'frame'
+            case words[1]
+              when 'time:'
+                if words[2] =~ /[^0-9\.]/
+                  raise ArgumentError, "Only one positive numeric decimal value expected at this time (not #{words[2]})"
+                end
+                bvh.frame_time = words[2].to_f
+              else
+                raise ArgumentError, "Motion data not understood: #{line}"
+            end
+          when nil, '' # blank line, do nothing
+          else
+            channels = words.collect do |w|
+              raise ArgumentError, "Only numeric values are expected at this time (not #{w})" if w =~ /[^0-9\.\-]/
+              w.to_f
+            end
+            add_frame(channels)
+        end
+      end
+      unless frame_count.nil? or frame_count == bvh.frame_count
+        raise ArgumentError, "Expected %s frames, found %s" % [frame_count, bvh.frame_count]
+      end
+      unless frame_count == 0
+        raise ArgumentError, "Frame time is 0; this would result in infinite FPS!" if bvh.frame_time == 0
+        raise ArgumentError, "Frame time is #{bvh.frame_time}! Should be a positive number." if bvh.frame_time < 0
+      end
+    end
+
+    def add_frame(channels)
+      frame = Bvh::Motion::Frame.new
+      frame.channel_data.concat channel_data(channels, bvh.root)
+      bvh.frames << frame
+      raise ArgumentError, "Not enough channels: Need #{-channels.length} more" if channels.length < 0
+      raise ArgumentError, "Too many channels: #{channels.length} unaccounted for" if channels.length > 0
+    end
+
+    # this is now a binding.
+#    def channel_data(channels, bone)
+#      return [] unless bone.respond_to? :channels
+#      data = Bvh::Motion::ChannelData.new(bone)
+#      bone.channels.each do |channel|
+#        data[channel] = channels.shift
+#      end
+#      r = [ data ]
+#      if bone.respond_to? :joints
+#        bone.joints.each do |child|
+#          r.concat channel_data(channels, child)
+#        end
+#      end
+#      r
+#    end
+  end
+end

data/lib/bvh/skeleton.rb

@@ -0,0 +1,84 @@
+class Bvh
+  class Skeleton
+    attr_accessor :root
+
+    def find_by_name(name); root.find_by_name(name); end
+
+    alias / find_by_name
+
+    class Bone
+      # the name of this bone
+      attr_accessor :name
+
+      # this bone's parent bone, if any (if nil, this bone is a root)
+      attr_reader :parent
+
+      # the channels, or degrees of freedom, that this bone allows -- and the order that they appear in
+      attr_reader :channels
+
+      # the offset of this bone in relation to its parent
+      attr_reader :offset
+
+      # an array of joints, or child bones. Each should have its parent set to this bone. See also #add_joint!
+      attr_reader :joints
+
+      def initialize(name = nil, parent = nil)
+        @name, @parent = name, parent
+        @channels, @offset, @joints = [], [], []
+        @frames = []
+      end
+
+      # Adds the specified bone to this bone's list of joints, setting its parent equal to this bone.
+      # This bone is returned.
+      def add_joint!(joint)
+        joint.instance_variable_set("@parent", self)
+        raise "Cannot add joint: name '#{joint.name}' already exists" if self / joint.name
+        joints << joint unless joints.include? joint
+        self
+      end
+
+      # returns true if this is a "leaf" node; that is, there are no joints
+      def end_site?
+        joints.length == 0
+      end
+
+      # returns the descendant joint (or self) with the specified name.
+      def find_by_name(name)
+        return self if self.name == name
+        joints.each { |j| r = j.find_by_name(name); return r unless r.nil? }
+        nil
+      end
+
+      # Returns the length of this bone, inferred from the offset of its first joint.
+      def length
+        if end_site? then 0
+        else
+          ofs = joints.first.offset
+          # ofs is a vector, so we need its magnitude
+          if ofs.nil? then 0
+          else Math.sqrt(ofs[0]**2) + Math.sqrt(ofs[1]**2) + Math.sqrt(ofs[2]**2)
+          end
+        end
+      end
+
+      # Returns a unit vector representing the orientation of this bone, inferred from the offset of its first joint.
+      def orientation
+        if end_site? then [0,0,0]
+        else
+          ofs = joints.first.offset
+          if ofs.nil? then [0,0,0]
+          else
+            # ofs is a vector, so we need to normalize it
+            max = proc { |a,b| a.to_f.abs > b.to_f.abs ? a.to_f.abs : b.to_f.abs }
+            max = max.call(ofs[0], max.call(ofs[1], ofs[2]))
+            if max > 0 then [ofs[0].to_f / max, ofs[1].to_f / max, ofs[2].to_f / max]
+            else [0,0,0]
+            end
+          end
+        end
+      end
+
+      alias / find_by_name
+    end
+  end
+end

data/test/bvh_test.rb

@@ -0,0 +1,62 @@
+require 'helper'
+
+### Since I don't really have much data to test against, this file mostly just tests that no
+### errors are encountered.
+###
+### FIXME: Add assertion data.
+###
+class BvhTest < Test::Unit::TestCase
+  context "The Bvh class" do
+    should "import BVH files" do
+      Bvh.import(File.join(test_path, "data/in/karate.bvh"))
+    end
+  end
+
+  context "A Bvh instance" do
+    setup do
+      @karate = Bvh.import(File.join(test_path, "data/in/karate.bvh"))
+    end
+
+    should "export to file" do
+      @karate.export(File.join(test_path, "data/out/karate.bvh"))
+    end
+
+    should "be able to import its own exports" do
+      @karate.export(File.join(test_path, "data/out/karate.bvh"))
+      Bvh.import(File.join(test_path, "data/out/karate.bvh"))
+    end
+
+    should "be able to calculate the transform matrices" do
+      frames = @karate.motion.frames
+      bone = @karate.skeleton/"LeftWrist"
+
+      # FIXME: i don't know what values to assert against
+      frames.last.local_transform_matrix(bone)
+      frames.last.transform_matrix(bone)
+    end
+
+    should "be able to add time to frames" do
+      # add 3 seconds, during which each bone's offset should move and rotate by 3 units
+      # no idea what this would look like if rendered, it's just a test
+      frame_count = @karate.frame_count
+      @karate.motion.add_time(3, @karate.motion.frames.last + 3)
+      assert_equal frame_count+90, @karate.frame_count # 30 fps for 3 sec
+    end
+
+    context "A Bone" do
+      setup do
+        @bone = @karate.skeleton/"LeftWrist"
+      end
+
+      should "have a length" do
+        len = @bone.length
+        assert_equal 7.0, len
+      end
+
+      should "have an orientation" do
+        orientation = @bone.orientation
+        assert_equal [0,-1,0], orientation
+      end
+    end
+  end
+end