bvh 1.0.0 → 1.0.1

data/lib/bvh/motion/frame.rb

@@ -1,124 +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
+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

@@ -1,177 +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
+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