bvh 1.0.0

data/ext/bvh/bvh.h

@@ -0,0 +1,10 @@
+#ifndef BVH_EXT_H
+#define BVH_EXT_H
+
+#include "ruby.h"
+
+extern void bvh_init_parser();
+
+extern VALUE rb_cBvh;
+
+#endif//BVH_EXT_H

data/ext/bvh/bvh_parser.c

@@ -0,0 +1,63 @@
+#include "bvh.h"
+
+static VALUE rb_fParseChannelData(VALUE self, VALUE channels, VALUE bone);
+
+static VALUE rb_cBvhParser = Qnil;
+static VALUE rb_cMotion = Qnil;
+static VALUE rb_cChannelData = Qnil;
+
+void bvh_init_parser()
+{
+    rb_cBvhParser = rb_define_class_under(rb_cBvh, "Parser", rb_cObject);
+    rb_cMotion = rb_define_class_under(rb_cBvh, "Motion", rb_cObject);
+    rb_cChannelData = rb_define_class_under(rb_cMotion, "ChannelData", rb_cHash);
+
+    rb_define_private_method(rb_cBvhParser, "channel_data", rb_fParseChannelData, 2);
+}
+
+static void debug(const char *text)
+{
+    rb_funcall(rb_cObject, rb_intern("puts"), rb_str_new2(text));
+}
+
+static VALUE rb_fParseChannelData(VALUE self, VALUE channels, VALUE bone)
+{
+    char buf[256];
+    
+    VALUE data;
+    struct RArray *rchannels, *joints;
+    long i;
+    VALUE channel, joint;
+    VALUE r = rb_ary_new();
+
+    // return [] unless bone.respond_to? :channels
+    if (!rb_respond_to(bone, rb_intern("channels")))
+        return r;
+
+    // data = Bvh::Motion::ChannelData.new(bone)
+    data = rb_funcall(rb_cChannelData, rb_intern("new"), 1, bone);
+
+    // bone.channels.each { |channel| data[channel] = channels.shift }
+    rchannels = RARRAY(rb_funcall(bone, rb_intern("channels"), 0));
+    for (i = 0; i < rchannels->len; i++)
+    {
+        channel = *(rchannels->ptr+i);
+        //... data[channel] = channels.shift ...
+        rb_hash_aset(data, channel, rb_funcall(channels, rb_intern("shift"), 0));
+    }
+
+    // r = [data]
+    rb_ary_push(r, data);
+
+    // bone.joints.each { |joint| r.concat channel_data(channels, joint) }
+    joints = RARRAY(rb_funcall(bone, rb_intern("joints"), 0));
+    for (i = 0; i < joints->len; i++)
+    {
+        joint = *(joints->ptr+i);
+        // ... r.concat(channel_data(channels, joint)) ...
+        rb_funcall(r, rb_intern("concat"), 1, rb_fParseChannelData(self, channels, joint));
+    }
+
+    // r
+    return r;
+}

data/ext/bvh/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+
+dir_config('bvh')
+create_makefile('bvh')

data/lib/bvh.rb

@@ -0,0 +1,74 @@
+require 'bvh.so'
+require 'bvh/matrix'
+require 'bvh/motion'
+require 'bvh/motion/channel_data'
+require 'bvh/motion/frame'
+require 'bvh/skeleton'
+require 'bvh/parser'
+require 'bvh/exporter'
+
+
+class Bvh
+  # The array of skeletons associated with this BVH.
+  attr_reader :skeletons
+
+  # The motion capture data associated with this BVH.
+  attr_reader :motion
+
+  def initialize
+    @motion = Bvh::Motion.new
+    @skeletons = []
+  end
+
+  # Assigns the root bone in #skeleton
+  def root=(a); skeleton.root = a; end
+
+  # Returns the root bone in #skeleton
+  def root; skeleton.root; end
+
+  # Returns the frame data associated with this BVH file.
+  def frames; motion.frames; end
+
+  # Returns the last frame associated with this animation.
+  def last_frame; frames.last; end
+
+  # Returns the amount of time, in seconds, each frame occupies. Most BVH files have this set to
+  # 0.333333, which is equal to 30 frames per second.
+  def frame_time; motion.frame_time; end
+
+  # Sets the amount of time, in seconds, each frame occupies. Most BVH files have this set to
+  # 0.333333, which is equal to 30 frames per second.
+  def frame_time=(a); motion.frame_time = a; end
+
+  # Returns the frames per second calculated by (1 / frame_time)
+  def frames_per_second; motion.frames_per_second; end
+
+  # Assigns the frame_time by calculating it from (1 / frames_per_second)
+  def frames_per_second=(a); motion.frames_per_second = a; end
+
+  # Returns the number of frames in the motion capture data.
+  def frame_count; motion.frame_count; end
+
+  # Returns the first (and usually the only) skeleton in the #skeletons array.
+  def skeleton; @skeletons.first; end
+
+  # Creates a new skeleton, adds it to the #skeletons array, and returns it.
+  def create_skeleton!; (@skeletons << Bvh::Skeleton.new).last; end
+
+  class << self
+    # Instantiates a new BVH and imports its data from the specified file
+    def import(file)
+      bvh = self.new
+      parser = Bvh::Parser.new(file)
+      parser.parse(bvh)
+      bvh
+    end
+  end
+
+  # Exports this BVH into the specified file.
+  def export(file)
+    exporter = Bvh::Exporter.new(file)
+    exporter.export(self)
+    self
+  end
+end

data/lib/bvh/exporter.rb

@@ -0,0 +1,86 @@
+class Bvh
+  class Exporter
+    attr_reader :filename
+    attr_reader :source
+
+    def initialize(file)
+      @filename = file
+    end
+
+    def export(bvh)
+      #raise "File exists" if File.exist?(filename)
+      unless bvh.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
+      @bvh = bvh
+      File.open(filename, "w+") do |file|
+        @file = file
+        file.puts "HIERARCHY"
+        bvh.skeletons.each { |skel| export_skeleton(skel) }
+        export_motion(bvh.motion)
+        file.puts # end with a blank line
+      end
+    end
+
+    private
+    attr_reader :bvh, :file
+
+    # export HIERARCHY data
+    def export_skeleton(skele)
+      export_root skele.root
+    end
+
+    # export ROOT node and its joints
+    def export_root(root)
+      file.puts "ROOT #{root.name}"
+      file.puts "{"
+      export_bone_data(root)
+      file.puts "}"
+    end
+
+    # export JOINT node, or End Site if joint has no joints
+    # level defines number of preceding tab stops
+    def export_joint(bone, level = 1)
+      tabs = "\t"*level
+      header = if bone.end_site? then "End Site"
+      else "JOINT #{bone.name}" 
+      end
+      file.puts "#{tabs}#{header}"
+      file.puts "#{tabs}{"
+      export_bone_data(bone, level)
+      file.puts "#{tabs}}"
+    end
+
+    # exports bone data, regardless of type, including its joints
+    # level defines number of preceding tab stops
+    def export_bone_data(bone, level = 0)
+      level += 1 # we're within a node, so it's one more tab than expected
+      tabs = "\t"*level
+      file.puts "#{tabs}OFFSET\t #{bone.offset.collect { |i| "%.6f" % i }.join("\t ")}"
+      if bone.channels.length > 0
+        chans = bone.channels.join(" ")
+        file.puts("#{tabs}CHANNELS #{bone.channels.length} #{chans}")
+      end
+      bone.joints.each { |joint| export_joint(joint, level) }
+    end
+
+    # export MOTION data
+    def export_motion(motion)
+      file.puts "MOTION"
+      file.puts "Frames: #{motion.frame_count}"
+      file.puts "Frame Time: #{motion.frame_time}"
+      motion.frames.each do |frame|
+        line = ""
+        # chan.bone.channels vs. chan.channels to maintain order
+        frame.channel_data.each do |channel_data|
+          channel_data.bone.channels.each do |i|
+            chan = "%.6f" % channel_data[i]
+            line = "#{line}#{chan}\t"
+          end
+        end
+        file.puts line.strip
+      end
+    end
+  end
+end

data/lib/bvh/matrix.rb

@@ -0,0 +1,19 @@
+require 'matrix'
+
+# This adds a few methods to the default Ruby Matrix implementation.
+class Matrix
+  # Sets row "i", column "j", to the value "x".
+  def []=(i,j,x)
+    @rows[i][j] = x
+  end
+
+  # Turns this matrix into an identity matrix, erasing all previous values.
+  def load_identity!
+    row_size.times do |r|
+      column_size.times do |c|
+        self[r, c] = (r == c ? 1 : 0)
+      end
+    end
+    self
+  end
+end

data/lib/bvh/motion.rb

@@ -0,0 +1,79 @@
+class Bvh
+  class Motion
+    # The amount of time that passes for each frame. Most BVH files have this set to 0.0333, or 30 frames per second.
+    # The following calculations might also be useful to you:
+    #    frame_time = 1 / frames_per_second   # =>  0.0333 = 1 / 30
+    #    frames_per_second = 1 / frame_time   # =>  30 = 1 / 0.0333
+    attr_accessor :frame_time
+
+    # The array of frames in this animation. You can modify this directly if you wish.
+    attr_reader :frames
+
+    # Returns the frames per second calculated by (1 / frame_time)
+    def frames_per_second; 1 / frame_time; end
+
+    # Assigns the frame_time by calculating it from (1 / frames_per_second)
+    def frames_per_second=(a); self.frame_time = 1 / a; end
+
+    def initialize
+      @frames = []
+    end
+
+    # Returns the number of frames in this animation.
+    def frame_count
+      frames.length
+    end
+
+    # Adds the specified frame or frames to the end of this animation.
+    def add_frame(*frames)
+      self.frames.concat frames.flatten
+    end
+
+    # Creates a single frame that is an exact copy of the last frame in this animation.
+    def create_frame
+      frames.last.copy
+    end
+
+    # Creates N frames via #create_frame.
+    def create_frames(n)
+      r = []
+      n.times { r << create_frame }
+      r
+    end
+
+    # Creates enough frames to fill the specified number of seconds, adds them to the animation, and returns self.
+    #
+    # target_frame is the state at which the animation should be in upon reaching the final frame of the alotted time.
+    # If it contains data that is different from the last frame in this animation, then the result will be an
+    # interpolation between the two over the course of the alotted time.
+    #
+    # You can use this method to specify key points in the animation, and produce a fluid result.
+    def add_time(seconds, target_frame = frames.last)
+      raise "Can't calculate frames from seconds: frame_time is zero!" if frame_time == 0
+      num_frames = (seconds / frame_time).to_i
+      return self if num_frames == 0
+
+      # buf holds the amount to change each frame
+      buf = (frames.last - target_frame) / num_frames.to_f
+
+      num_frames.times do |i|
+        if i == (num_frames-1) then add_frame(target_frame.copy) # last iteration, last frame... we can cheat.
+        else add_frame(create_frame + buf) # create_frame clones the last frame, and buf moves it closer to target
+        end
+      end
+
+      self
+    end
+
+    # Chops the specified amount of time off of the end of this animation and then returns self.
+    def truncate_time(seconds)
+      raise "Can't calculate frames from seconds: frame_time is zero!" if frame_time == 0
+      num_frames = (seconds / frame_time).to_i
+      return self if num_frames == 0
+      frames[-1..-num_frames].each { |i| frames.delete i }
+      self
+    end
+
+    alias add_frames add_frame
+  end
+end

data/lib/bvh/motion/channel_data.rb

@@ -0,0 +1,147 @@
+class Bvh
+  class Motion
+    class ChannelData < Hash
+      # The bone that is related to this channel data.
+      attr_reader :bone
+
+      def initialize(bone, *args, &block)
+        @bone = bone
+        super(*args, &block)
+      end
+
+      # call-seq:
+      #   channel_data + channel_data  => new_channel_data
+      #   channel_data - channel_data  => new_channel_data
+      #   channel_data / channel_data  => new_channel_data
+      #   channel_data * channel_data  => new_channel_data
+      #   channel_data + number => new_channel_data
+      #   channel_data - number => new_channel_data
+      #   channel_data / number => new_channel_data
+      #   channel_data * number => new_channel_data
+      #
+      # Performs arithmetic on this frame with the target. The second operand may be either a number or another
+      # ChannelData. If the target is a number, then that number is added to, subtracted from, multiplied with, or
+      # divided against each channel of this ChannelData.
+      #
+      # If the target is another ChannelData, the arithmetic looks something like this:
+      #   return_value['Xposition'] = channel_data_one['Xposition'] * channel_data_two['Xposition']
+      #   return_value['Yposition'] = channel_data_one['Yposition'] * channel_data_two['Yposition']
+      #   return_value['Zposition'] = channel_data_one['Zposition'] * channel_data_two['Zposition']
+      #   . . .
+      #
+      # Both objects must contain the same number of channels, and must also reference the same bone.
+      #
+      # Returns a new instance of ChannelData containing the result.
+      #
+      def arithmetic_proc(target)
+        # Fooled you again! I metaprogrammed it to save some typing!
+      end
+      undef arithmetic_proc
+
+      [:+, :-, :/, :*].each do |operator|
+        define_method operator do |target|
+          ret = ChannelData.new(bone)
+          if target.kind_of?(ChannelData)
+            target.each { |key, value| ret[key] = 0.send(operator, value) }
+            self.each do |key, value|
+              ret[key] = value.send(operator, 0)
+              ret[key] = value.send(operator, target[key]) if target.key?(key)
+            end
+          else
+            self.each { |key, value| ret[key] = value.send(operator, target) }
+          end
+          ret
+        end
+      end
+
+      # Sets the specified channel to a value of theta, and then returns self.
+      def set_channel(channel, theta)
+        channel = channel.to_s if channel.kind_of? Symbol
+        raise "Channel not found: #{channel} (expected one of #{self.keys.inspect})" unless self.keys.include? channel
+        self[channel] = theta
+      end
+
+      # Retrieves and returns the specified channel datum, raising an error if its key is not found.
+      # If the channel key is a symbol, it is converted to a string before the lookup is performed.
+      def get_channel(channel)
+        channel = channel.to_s if channel.kind_of?(Symbol)
+        raise "Channel not found: #{channel} (expected one of #{self.keys.inspect})" unless self.keys.include?(channel)
+        self[channel]
+      end
+
+      # Modifies the specified channel datum, resulting in a rotation around the specified channel.
+      def rotate!(channel, theta)
+        theta = get_channel(channel)+theta
+        # this doesn't really have an effect, but may help keep the file from getting junked.
+        if theta >= 360 then theta %= 360
+        elsif theta <= -360 then theta %= -360
+        end
+        set_channel(channel, theta)
+      end
+
+      # Adds x, y and z to the X, Y and Z position channels, resulting in a "movement" or translation.
+      def translate!(x, y, z)
+        set_channel('Xposition', get_channel('Xposition')+x)
+        set_channel('Yposition', get_channel('Yposition')+y)
+        set_channel('Zposition', get_channel('Zposition')+z)
+      end
+
+      # Returns the transform matrix for this bone's channel data. See also
+      # Frame#relative_transform_matrix and Frame#absolute_transform_matrix.
+      #
+      # The resultant matrix needs to be multiplied against the parent bone's transform matrix in order
+      # to be accurate to worldspace. Otherwise it's only accurate in local space. If you're not sure what
+      # that means, then use Frame#absolute_transform_matrix instead.
+      def relative_transform_matrix()
+        # theta is retrieved from the set of numbers loaded from the BVH file, or is supplied directly
+        #
+        # R is the matrix calculated for a rotation of theta degrees around the vector V
+        #    This is performed on right, view and up vectors, multiplying the three matrices together
+        #    to construct the rotation matrix for this bone. Since the calculations are done in world
+        #    space, the right, up and view vectors are [1,0,0]; [0,1,0]; [0,0,1], respectively. No reason
+        #    we couldn't attach a Camera object to this bone and figure it out that way, but it'd actually
+        #    be more work to create and maintain the camera than to just calculate the matrix. Obviously,
+        #    the resultant matrix needs to be multiplied against the parent bone's rotation matrix in order
+        #    to be accurate to worldspace. Otherwise it's only accurate in local space.
+        #
+        # R = [tx^2 + c,  txy - sz,  txz + sy,  0]
+        #     [txy + sz,  ty^2 + c,  tyz - sx,  0]
+        #     [txz - sy,  tyz + sx,  tz^2 + c,  0]
+        #     [       0,         0,         0,  1]
+        #
+        # where c = cos theta,
+        #       s = sin theta,
+        #       t = 1 - c
+        # [x,y,z] = a unit vector on the axis of rotation
+
+        # bone.channels.each so that we don't lose order of operation
+        r = Matrix.identity(4)
+        bone.channels.each do |chan|
+          v = nil
+          case chan
+            when 'Xrotation' then v = [1,0,0] # right vector
+            when 'Yrotation' then v = [0,1,0] # up vector
+            when 'Zrotation' then v = [0,0,1] # view vector
+            else next # ignore nonrotational values. To my knowledge, this includes only position values.
+          end
+          theta = self[chan]
+          x, y, z = v
+          c, s, t = Math.cos(theta), Math.sin(theta), 1 - Math.cos(theta)
+          mat = Matrix.identity(4)
+          mat[0,0], mat[0,1], mat[0,2] = t*(x**2) + c, t*x*y - s*z, t*x*z + s*y
+          mat[1,0], mat[1,1], mat[1,2] = t*x*y + s*z, t*(y**2) + c, t*y*z - s*x
+          mat[2,0], mat[2,1], mat[2,2] = t*x*z - s*y, t*y*z + s*x, t*(z**2) + c
+          r *= mat
+        end
+
+        # Finally, the last row is simply set to the translation and/or bone offset.
+        r[0,3] = bone.offset[0] + (self.key?("Xposition") ? self['Xposition'] : 0)
+        r[1,3] = bone.offset[1] + (self.key?("Yposition") ? self['Yposition'] : 0)
+        r[2,3] = bone.offset[2] + (self.key?("Zposition") ? self['Zposition'] : 0)
+        r
+      end
+
+      alias local_transform_matrix relative_transform_matrix
+    end
+  end
+end