pangdudu-mamba 0.1

data/README.rdoc

@@ -0,0 +1,26 @@
+= Mamba
+
+Hi girls and boys!
+
+This is a Qt4 ruby tool for analysis of ART tracker data time series generated
+by the ART motion capturing system.
+
+== Installation
+
+  sudo gem install pangdudu-mamba --source=http://gems.github.com
+	 	 
+== Usage
+
+  ruby mamba.rb
+  
+== Config
+
+Is still hardcoded in the source files. :)
+
+== Rule the universe! 
+
+Oh mighty gods of ruby, please make the GIL go away!
+
+== License
+
+GPL -> http://www.gnu.org/licenses/gpl.txt

data/lib/b1trackerdata/b1_data_parser.rb

@@ -0,0 +1,230 @@
+=begin
+  This file e.g. the TrackerDataParser fetches the tracker data from the 
+  database, and parses them according to the "SFB673TPB1 Annotation Manual".
+=end
+
+require "rubygems"
+require "narray"
+require "sequel"
+require "rofl"
+
+#connect to the database
+DB = Sequel.connect(:adapter=>'mysql', :host=>'localhost', :database=>'database', :user=>'user', :password=>'password')
+
+class TrackerDataParser
+  
+  attr_accessor :data
+  
+  def initialize trial,test=false
+    @trial = trial
+    tablename = "Tracker#{trial}"
+    tablename = "TrackerTest" if test
+    dlog "Trying to connect to table: #{tablename}"
+    #get our rows
+    @rows = DB[tablename.to_sym]
+    @highpass = 0.25 #for later filtering
+    dlog "Table has #{@rows.count} rows."
+    #processed data will end up here
+    @data = {:left => {}, :right => {}}
+    #do we know that one marker has been worn wrong?
+    @data[:left_twist] = false
+    @data[:right_twist] = false
+    #get and parse the tracker data
+    operate
+  end
+  
+  #main controller function
+  def operate
+    @data[:reference] = (parsetrackerdata @rows.filter(:identifier => "Neck")).sort
+    dlog "Parsed neckdata count is #{@data[:reference].length}"
+    left_raw = (parsetrackerdata @rows.filter(:identifier => "Left_Hand")).sort
+    dlog "Left hand quality is #{(Float(left_raw.length)/Float(@data[:reference].length))*100}%"
+    right_raw = (parsetrackerdata @rows.filter(:identifier => "Right_Hand")).sort
+    dlog "Right hand quality is #{(Float(right_raw.length)/Float(@data[:reference].length))*100}%"
+    
+    #sometimes people are wearing the tracker wrong, need to fix this
+    fix_marker_twist
+    
+    #now parse the tracker data for both hands    
+    left_raw.each do |timestamp,matrix|
+      d = getannotationdata timestamp,matrix,@data[:left_polarity]
+      @data[:left][timestamp] = d unless d.nil?
+    end
+    right_raw.each do |timestamp,matrix|
+      d = getannotationdata timestamp,matrix,@data[:right_polarity]
+      @data[:right][timestamp] = d unless d.nil?
+    end
+    #Debug and info
+    ilog "Statistics for trial #{@trial}:"
+    ilog "  Left hand  - parsed: #{@data[:left].length}"
+    ilog "  Right hand - parsed: #{@data[:right].length}"
+  end
+  
+  #method parsing tracking data from the db and loading it into an hash(organized by timestamp)
+  def parsetrackerdata trackerdata
+    parseddata = {}
+    trackerdata.each do |d|
+      m = NMatrix.float(4,4)
+      #that's how the coordinates would look if the matrix was transposed (now the bottom is 0,0,0,1)
+      m[0,0],m[0,1],m[0,2],m[0,3] = d[:m00], d[:m01], d[:m02], d[:m03]
+      m[1,0],m[1,1],m[1,2],m[1,3] = d[:m10], d[:m11], d[:m12], d[:m13]
+      m[2,0],m[2,1],m[2,2],m[2,3] = d[:m20], d[:m21], d[:m22], d[:m23]
+      m[3,0],m[3,1],m[3,2],m[3,3] = d[:m30], d[:m31], d[:m32], d[:m33]
+      m = m.transpose #matrix data in the db are transposed
+      parseddata[Float(d[:timestamp])] = m
+    end
+    return parseddata
+  end
+
+  def getannotationdata timestamp,matrix,polarity
+    annotationdata = {}
+    reference = @data[:reference][timestamp][1]
+    relative = reference.inverse * matrix * polarity
+    annotationdata[:timestamp] = timestamp
+    annotationdata[:reference] = reference
+    annotationdata[:data] = matrix
+    annotationdata[:relative] = relative
+    annotationdata[:boh] = getbackofhanddirection relative
+    annotationdata[:pd] = getpalmdirection relative
+    annotationdata[:wp] = getwristposition relative
+    annotationdata[:we] = getwristextend relative
+    return annotationdata
+  end
+
+  #function computing palm direction
+  def getpalmdirection data
+    #negative z seems to be the palm direction
+    #you should check the data in the visualization to be sure
+    x,y,z = (-1)*data[2,0],(-1)*data[2,1],(-1)*data[2,2]
+    result = []
+    result << "PAB" if z < -@highpass
+    result << "PDN" if y < -@highpass
+    result << "PTB" if z > @highpass
+    result << "PTL" if x < -@highpass
+    result << "PTR" if x > @highpass
+    result << "PUP" if y > @highpass
+    return result.join("/")
+  end
+
+  #function computing back of hand direction
+  def getbackofhanddirection data
+    #ok, it looks like the markers y axis is the boh direction
+    #you should check the data in the visualization to be sure
+    x,y,z = data[1,0],data[1,1],data[1,2]
+    result = []
+    result << "BAB" if z < -@highpass
+    result << "BDN" if y < -@highpass
+    result << "BTB" if z > @highpass
+    result << "BTL" if x < -@highpass
+    result << "BTR" if x > @highpass
+    result << "BUP" if y > @highpass
+    return result.join("/")
+  end
+
+  #function computing wrist extend
+  def getwristextend data
+    result = "aight!"
+    x,y,z = data[3,0],data[3,1],data[3,2]
+    #puts "wp: x '#{x}', y '#{y}', z '#{z}'"
+    zf = 100 #normalizing factor (100 = SH standard human)
+    xf = 100 #normalizing factor (100 = SH standard human)
+    x = x*xf
+    z = z*zf
+    r = Math.sqrt(x*x + z*z)
+    #ok, need to put real values in here (look at the annotationmanual)
+    result = "D-GTO" if r > 80 #greater than length of outstretched arm in front away
+    result = "D-KO" if r <= 80 #between knee and length of outstretched arm in front away
+    result = "D-EK" if r < 65 #between elbow and knee
+    result = "D-CE" if r < 45 #between body and elbows length away
+    result = "D-C" if r < 20 #in contact with body
+    #puts "extend is '#{result}'"
+    return result
+  end
+
+  #function computing wrist position
+  def getwristposition data
+    result = "aight!"
+    #negative z seems to be palm direction
+    #you should check the data in the visualization to be sure
+    x,y,z = data[3,0],data[3,1],data[3,2]
+    yf = 100
+    xf = 100
+    x = x*xf
+    y = y*yf
+    #puts "wp: x '#{x}', y '#{y}', z '#{z}'"
+    #will not be rock solid, so we go from outwards->inwards
+    #extreme periphery
+    eperiphery = "EP-"
+    eperiphery += "UP" if(y > 30 && x.abs <= 19)
+    eperiphery += "UL" if(y > 17 && x < -19)
+    eperiphery += "UR" if(y > 17 && x > 19)
+    eperiphery += "LT" if(y <= 17 && y > -17 && x < -31.5)
+    eperiphery += "RT" if(y <= 17 && y > -17 && x > 31.5)
+    eperiphery += "LW" if(y < -30 && x.abs <= 19)
+    eperiphery += "LL" if(y < -17 && x < -19)
+    eperiphery += "LR" if(y < -17 && x > 19)
+    result = eperiphery unless eperiphery.eql?("EP-")
+    #periphery
+    if (x.abs <= 31.5 && y.abs <= 30)
+      periphery = "P-"
+      periphery += "UP" if(y > 17 && x.abs <= 13)
+      periphery += "UL" if(y > 9 && x < -13)
+      periphery += "UR" if(y > 9 && x > 13)
+      periphery += "LT" if(y <= 9 && y > -10 && x < -21)
+      periphery += "RT" if(y <= 9 && y > -10 && x > 21)
+      periphery += "LW" if(y <= -10 && y > -30 && x.abs <= 13)
+      periphery += "LL" if(y <= -10 && y > -30 && x < -13)
+      periphery += "LR" if(y <= -10 && y > -30 && x > 13)
+      result = periphery unless periphery.eql?("P-")
+    end
+    #center
+    if (x.abs <= 21 && y.abs <= 17)
+      center = "C-"
+      center += "UP" if(y > 9 && x.abs <= 10)
+      center += "UL" if(y > 4.5 && x < -10)
+      center += "UR" if(y > 4.5 && x > 10)
+      center += "LT" if(y <= 4.5 && y > -7 && x < -13)
+      center += "RT" if(y <= 4.5 && y > -7 && x > 13)
+      center += "LW" if(y <= -7 && y > -17 && x.abs <= 10)
+      center += "LL" if(y <= -7 && y > -17 && x < -10)
+      center += "LR" if(y <= -7 && y > -17 && x > 10)
+      result = center unless center.eql?("C-")
+    end
+    #center-center
+    if (x.abs <= 13 && y.abs <= 9)
+      result = "CC"
+    end
+    #puts "result #{result}"
+    return result
+  end
+  
+  #method to fix the direction of the marker, if it has been worn wrong
+  def fix_marker_twist
+    #left hand
+    @data[:left_polarity] = NMatrix.float(4,4).unit
+    if @data[:left_twist]
+      p = NMatrix.float(4,4).unit
+      #if y direction of tracker is WRONG we need to rotate around z axis by 180 deg
+      p[0,0], p[0,1], p[1,0], p[1,1] = Math.cos(Math::PI),-Math.sin(Math::PI),Math.sin(Math::PI),Math.cos(Math::PI)
+      ilog "Will multiply left hand with this polarity matrix: #{p.inspect}"
+      @data[:left_polarity] = p
+    end
+    #and the right hand
+    @data[:right_polarity] = NMatrix.float(4,4).unit
+    if @data[:right_twist]
+      p = NMatrix.float(4,4).unit
+      #if y direction of tracker is WRONG we need to rotate around z axis by 180 deg
+      p[0,0], p[0,1], p[1,0], p[1,1] = Math.cos(Math::PI),-Math.sin(Math::PI),Math.sin(Math::PI),Math.cos(Math::PI)
+      ilog "Will multiply right hand with this polarity matrix: #{p.inspect}"
+      @data[:right_polarity] = p
+    end
+  end  
+end
+
+#for testing
+if false
+  tdp = TrackerDataParser.new "V06",true #will select table TrackerTest
+  require "openglviewer"
+  ogv = OpenGlViewer.new tdp.data
+  ogv.run
+end

data/lib/b1trackerdata/openglviewer.rb

@@ -0,0 +1,278 @@
+require 'rubygems'
+require 'opengl'
+require 'rational'
+require 'narray'
+require 'rofl'
+#include Gl,Glu,Glut
+
+class OpenGlViewer
+
+  attr_accessor :currenttimestamp,:timestamps,:pause
+
+  STDOUT.sync = TRUE
+  POS = [0, 0, 0, 0.0]
+
+  def initialize data
+    @data = data
+    @base = NMatrix.float(4,4).unit
+    @matrices = {}
+    @matrices[:base] = @base
+    @currenttimestamp = 0.0
+    @current = 0
+    @timestamps = {}
+    @pause = true
+    @forward = true
+    @leftboh = "none"
+    @rightboh = "none"
+    filltimestamps
+    glShadeModel(GL::SMOOTH)
+    glNormal(0.0, 0.0, 1.0)
+    glLightfv(GL::LIGHT0, GL::POSITION, POS)
+    glEnable(GL::CULL_FACE)
+    glEnable(GL::LIGHTING)
+    glEnable(GL::LIGHT0)
+    glEnable(GL::DEPTH_TEST)
+    glEnable(GL::LINE_SMOOTH)
+    glEnable(GL::POINT_SMOOTH)
+    glClearColor(0.0, 0.0, 0.0, 0.0)
+  end
+
+  def filltimestamps
+    i = 0
+    @data[:reference].each do |timestamp,value|
+      @timestamps[i] = timestamp
+      i += 1
+    end
+    ilog "Found '#{@timestamps.count}'"
+    ilog "Will now try to display '#{@data[:left].count}' left and '#{@data[:right].count}' right hand values"
+  end
+
+  def fillmatrices
+    unless @data[:left][@currenttimestamp].nil?
+      #@matrices[:reference] = @data[:left][@currenttimestamp][:reference]
+      #@matrices[:left_hand_data] = @data[:left][@currenttimestamp][:data]
+      @matrices[:left_hand_relative] = @data[:left][@currenttimestamp][:relative]
+      @leftboh = @data[:left][@currenttimestamp][:boh]
+    end
+    unless @data[:right][@currenttimestamp].nil?
+      #@matrices[:reference] = @data[:right][@currenttimestamp][:reference]
+      #@matrices[:right_hand_data] = @data[:right][@currenttimestamp][:data]
+      @matrices[:right_hand_relative] = @data[:right][@currenttimestamp][:relative]
+      @rightboh = @data[:right][@currenttimestamp][:boh]
+    end
+  end
+
+  def setcurrenttimestamp
+    unless @pause
+      if @forward
+        @current += 1
+        @currenttimestamp = @timestamps[@current]
+      end
+      if !@forward
+        @current -= 1 unless (@current.eql? 0)
+        @currenttimestamp = @timestamps[@current]
+      end
+    end
+  end
+
+  # gl display method
+  def display
+    fillmatrices
+    setcurrenttimestamp
+    fps_control(60)
+    glClear(GL::COLOR_BUFFER_BIT | GL::DEPTH_BUFFER_BIT)
+    glColor(0.0, 0.0, 0.0)
+    glPushMatrix()
+    glRotate(@view_rotx, 1.0, 0.0, 0.0)
+    glRotate(@view_roty, 0.0, 1.0, 0.0)
+    glRotate(@view_rotz, 0.0, 0.0, 1.0)
+    @matrices.each { |k,v| draw_object k,v }
+    displayinfo
+    glPopMatrix()
+    glutSwapBuffers()
+    @frames = 0 if not defined? @frames
+    @t0 = 0 if not defined? @t0
+    @frames += 1
+    t = GLUT.Get(GLUT::ELAPSED_TIME)
+    if t - @t0 >= 5000
+      seconds = (t - @t0) / 1000.0
+      fps = @frames / seconds
+      @t0, @frames = t, 0
+      exit if defined? @autoexit and t >= 999.0 * @autoexit
+    end
+  end
+
+  def drawOneLine x1,y1,z1,x2,y2,z2
+    glBegin(GL_LINES)
+    glVertex(x1,y1,z1)
+    glVertex(x2,y2,z2)
+    glEnd()
+  end
+
+  def drawLineWithText text,scale,x,y,z
+    scale2 = scale*scale
+    glPushMatrix()
+    drawOneLine(0,0,0,scale*x,scale*y,scale*z)
+    glTranslate((scale*x),(scale*y),(scale*z))
+    glScale(1.0/(scale2),1.0/(scale2),1.0/(scale2))
+    text.each_byte { |x| glutStrokeCharacter(GLUT_STROKE_ROMAN, x) }
+    glScale(scale2,scale2,scale2)
+    glTranslate(-(scale*x),-(scale*y),-(scale*z))
+    glPopMatrix()
+  end
+
+  # draw an imd and its childs
+  def draw_object key,matrix
+    glPushMatrix()
+    scale = 10
+    translation_scale = 2
+    glTranslate(matrix[3,0]*scale*translation_scale,matrix[3,1]*scale*translation_scale,matrix[3,2]*scale*translation_scale)
+    glColor(1,0,0)
+    drawLineWithText "#{key} x",scale,matrix[0,0],matrix[0,1],matrix[0,2]
+    glColor(0,1,0)
+    drawLineWithText "#{key} y",scale,matrix[1,0],matrix[1,1],matrix[1,2]
+    glColor(0,0,1)
+    drawLineWithText "#{key} z",scale,matrix[2,0],matrix[2,1],matrix[2,2]
+    glTranslate(-matrix[3,0]*scale*translation_scale,-matrix[3,1]*scale*translation_scale,-matrix[3,2]*scale*translation_scale)
+    glPopMatrix()
+  end
+
+  def displayinfo
+    info = "Information:"
+    info += " timestamp: #{(@timestamps[@current]).to_s}"
+    info += " PAUSED" if @pause
+    info += " FORWARD" if (!@pause && @forward)
+    info += " REVERSE" if (!@pause && !@forward)
+    info += " BOH left:#{@leftboh} right:#{@rightboh}"
+    scale = 10
+    scale2 = scale*scale
+    glPushMatrix()
+    glTranslate((scale),(scale),(scale))
+    glScale(1.0/(scale2),1.0/(scale2),1.0/(scale2))
+    info.each_byte { |x| glutStrokeCharacter(GLUT_STROKE_ROMAN, x) }
+    glScale(scale2,scale2,scale2)
+    glTranslate(-(scale),-(scale),-(scale))
+    glPopMatrix()
+  end
+
+  def fps_control(fps)
+    t = GLUT.Get(GLUT::ELAPSED_TIME)
+    @t0_idle = t if !defined? @t0_idle
+    time_to_sleep = (1000./fps) - (t - @t0_idle)
+    sleep(time_to_sleep.to_f/1000) if time_to_sleep > 0
+    @t0_idle = t
+  end
+
+  # gets called when window is resized etc.
+  def reshape width, height
+    h = height.to_f / width.to_f
+    glViewport(0, 0, width, height)
+    glMatrixMode(GL::PROJECTION)
+    glLoadIdentity()
+    glFrustum(-1.0, 1.0, -h, h, 1.0, 1000.0)
+    glMatrixMode(GL::MODELVIEW)
+    setViewpoint
+  end
+
+  def idle
+    GLUT.PostRedisplay()
+  end
+
+  def setViewpoint
+    glMatrixMode(GL_MODELVIEW)
+    glLoadIdentity()
+    gluLookAt(@eyex, 0, @znear, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0)
+    glutPostRedisplay()
+  end
+
+  # Change view angle
+  def special (k, x, y)
+    case k
+    when GLUT::KEY_UP
+      @view_rotx += 5.0
+    when GLUT::KEY_DOWN
+      @view_rotx -= 5.0
+    when GLUT::KEY_LEFT
+      @view_roty += 5.0
+    when GLUT::KEY_RIGHT
+      @view_roty -= 5.0
+    end
+    GLUT.PostRedisplay()
+  end
+
+  # mouse ;)
+  def mouse button, state, x, y
+    changed = false
+    case button
+    when 3 then @eyex -= 5; changed = true;
+    when 4 then @eyex += 5; changed = true
+    end
+    setViewpoint if changed
+    @mouse = state
+    @x0, @y0 = x, y
+  end
+
+  # motion control
+  def motion x, y
+    if @mouse == GLUT::DOWN then
+      @view_rotz += @x0 - x
+      @view_roty += @y0 - y
+      setViewpoint
+    end
+    @x0, @y0 = x, y
+  end
+
+  #keyboard control handling
+  def keyboard(key, x, y)
+    case (key)
+    when ?s
+      @znear = @znear - 1
+    when ?w
+      @znear = @znear + 1
+    when ?a
+      @eyex = @eyex - 1
+    when ?d
+      @eyex = @eyex + 1
+    when ?f
+      @forward = true
+    when ?r
+      @forward = false
+    when ?p
+      togglepause
+    when 27 # Escape
+      exit
+    end
+    setViewpoint
+  end
+
+  def togglepause
+    @pause = !@pause
+    puts "Toggle pause now '#{@pause}'"
+  end
+
+  def visible(vis)
+    GLUT.IdleFunc((vis == GLUT::VISIBLE ? method(:idle).to_proc : nil))
+  end
+  #the loop
+  def run
+    @znear = 30
+    @eyex = 0
+    @view_rotx, @view_roty, @view_rotz = 0, 0, 0
+    glutInit
+    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB)
+    glutInitWindowSize(640, 480)
+    glutInitWindowPosition(0, 0)
+    glutCreateWindow($0)
+    glutDisplayFunc(method(:display).to_proc)
+    glutReshapeFunc(method(:reshape).to_proc)
+    glutSpecialFunc(method(:special).to_proc)
+    glutKeyboardFunc(method(:keyboard).to_proc)
+    glutMouseFunc(method(:mouse).to_proc)
+    glutMotionFunc(method(:motion).to_proc)
+    glutVisibilityFunc(method(:visible).to_proc)
+    glShadeModel(GL::SMOOTH)
+    glNormal(0.0, 0.0, 1.0)
+    glClearColor(0.0, 0.0, 0.0, 0.0)
+    glutMainLoop()
+  end
+end

data/lib/graph.rb

@@ -0,0 +1,194 @@
+=begin
+  This class is a little B1 specific. It implements the graph we'll later
+  visualize.
+=end
+
+require "rubygems"
+require "narray"
+require "Qt4"
+require "rofl"
+require "b1trackerdata/b1_data_parser"
+
+class Graph
+  
+  attr_accessor :points,:deltas
+  
+  def initialize trial,deltas,hfrac,test=false
+    #deltas we will compute
+    @deltas = deltas
+    ilog "Will compute deltas for #{@deltas.inspect}."
+    #in case the deltas are to small/big change this factor
+    @delta_factor = 256
+    #in case the angles are to small/big change this factor
+    @euler_factor = hfrac
+    #this factor governs how many pixels the points are away from another
+    @x_factor = 4
+    #get the data from the database
+    parser = TrackerDataParser.new trial,test
+    @data = parser.data
+    #generate unique array with all occuring timestamps and prepare @values
+    @timestamps = build_timestamps
+    #fill values (deltas,etc.)
+    @previous = {:left => NMatrix.float(4,4), :right => NMatrix.float(4,4)}
+    fill_values
+    #build the points array (this will be used later on to draw the graph)
+    @points = build_points
+  end
+  
+  #build an array with all occuring timestamps
+  def build_timestamps
+    @values = {}
+    tss = []
+    @data[:reference].each { |t,v| tss << t }
+    @data[:left].each { |t,v| tss << t }
+    @data[:right].each { |t,v| tss << t }
+    dlog "tss count: #{tss.length}"
+    timestamps = (tss.uniq).sort
+    dlog "Unique timestamps: #{timestamps.length}"
+    dlog "Unique timestamps first: #{timestamps.first}"
+    #now preparing @values
+    timestamps.each do |t|
+      @values[t] = {:left => {}, :right => {}}
+    end
+    return timestamps
+  end  
+  
+  #fill values with parsed data
+  def fill_values
+    [:left,:right].each do |hand|
+      dlog "Data for #{hand.inspect} has #{@data[hand].length} entries."
+      #it's crucial to do sort here, otherwise the timestamps are mixed up
+      @data[hand].sort.each do |t,v|
+        wlog "Empty or nil value hash!" if v.nil? or v.empty?
+        #we have tracker data
+        v[:blackout] = false
+        #will only happen the first time
+        @previous[hand] = v[:relative] if @previous[hand].abs.sum == 0.0
+        #compute euler angles
+        v[:euler] = compute_euler_angles(v)
+        #compute deltas for plotting
+        v[:deltas] = compute_deltas(hand,v)
+        #for next delta computation
+        @previous[hand] = v[:relative]
+        #put values into @values
+        @values[t][hand] = v
+      end
+    end
+    dlog "Processed #{@values.length} values."
+  end
+  
+  #compute euler angles for plotting
+  #http://en.wikipedia.org/wiki/Euler_angles
+  def compute_euler_angles values
+    #we'll put the angles in here
+    e = {}
+    #get the hand matrix
+    m = values[:relative]
+    #alpha = atan2(-Z2, Z1)
+    e[:alpha] = { :value => Math.atan2(-1.0*m[2,1],m[2,0]) }
+    #beta = atan2(Z3, sqrt(Z1^2+Z2^2))
+    e[:beta] = { :value => Math.atan2(m[2,2],Math.sqrt(m[2,0]**2+m[2,1]**2)) }
+    #gamma = -atan2(Y3,-X3) if Z3 < 0
+    e[:gamma] = { :value => -1.0*Math.atan2(m[1,2],-1.0*m[0,2]) } if m[2,2] <= 0.0
+    #gamma = atan2(Y3,X3) if Z3 > 0
+    e[:gamma] = { :value => Math.atan2(m[1,2],m[0,2]) } if m[2,2] > 0.0
+    return e
+  end  
+  
+  #compute deltas for plotting
+  def compute_deltas hand,values,t=0
+    #we'll put the deltas in here
+    ds = {}
+    #get the matrix
+    m = values[:relative]
+    #to reduce computation time we only compute what's needed
+    if @deltas.include? :simple
+      #compute simple delta over the complete 4x4 matrix
+      value = (m-@previous[hand]).abs.sum
+      ds[:simple] = { :value => value }
+    end
+    if @deltas.include? :pos
+      #compute simple delta over the position vector
+      value = (m[3,0..2]-@previous[hand][3,0..2]).abs.sum
+      ds[:pos] = { :value => value }
+    end
+    if @deltas.include? :rot
+      #compute simple delta over the 3x3 rotation matrix
+      value = (m[0..2,0..2]-@previous[hand][0..2,0..2]).abs.sum
+      ds[:rot] = { :value => value }  
+    end
+    if @deltas.include? :xrot
+      #compute simple delta over the x-rotation axis vector
+      value = (m[0,0..2]-@previous[hand][0,0..2]).abs.sum
+      ds[:xrot] = { :value => value }  
+    end
+    if @deltas.include? :yrot
+      #compute simple delta over the y-rotation axis vector
+      value = (m[1,0..2]-@previous[hand][1,0..2]).abs.sum
+      ds[:yrot] = { :value => value }
+    end
+    if @deltas.include? :zrot
+      #compute simple delta over the z-rotation axis vector
+      value = (m[2,0..2]-@previous[hand][2,0..2]).abs.sum
+      ds[:zrot] = { :value => value } 
+    end     
+    #and return the computed deltas
+    return ds
+  end
+  
+  #build the points array we'll use later on to draw the graph
+  def build_points
+    @timestamps.each_index do |i|
+      ts = @timestamps[i]
+      #do the following for both hands
+      [:left,:right].each do |h|
+        #if tracker data are missing we substitute
+        if @values.has_key? ts
+          @values[ts][h] = get_missing_values if @values[ts][h].empty?
+        end
+        #set index and x position
+        @values[ts][h][:i] = i
+        x = i*@x_factor
+        @values[ts][h][:x] = x
+        #now we create a Qt::PointF.new(x,y) for each euler angle
+        @values[ts][h][:euler].each do |name,a|
+          #create Point, mirror hands on x axis and apply y-scaling
+          y = 0
+          unless @values[ts][h][:blackout]
+            y += @euler_factor-a[:value]*@euler_factor/Math::PI 
+            y *= -1.0 if h.eql? :left
+          end
+          #and add the point to the euler values
+          @values[ts][h][:euler][name][:point] = Qt::PointF.new(x,y)
+        end
+        #now we create a Qt::PointF.new(x,y) for every delta type
+        @values[ts][h][:deltas].each do |type,delta|
+          #create Point, mirror hands on x axis and apply y-scaling
+          y = delta[:value]*@delta_factor
+          y *= -1.0 if h.eql? :left
+          #and add the point to the delta values
+          @values[ts][h][:deltas][type][:point] = Qt::PointF.new(x,y)
+        end
+      end  
+    end
+    dlog "Processed #{@values.length} timestamps."   
+    points = @values.sort
+    dlog "points array has #{points.length} entries."
+    return points
+  end
+
+  #in case values are missing for timestamps (no tracker data), we'll supply values
+  def get_missing_values
+    #we'll put the deltas in here
+    missing_deltas = {}
+    #put 0.0 to deltas
+    @deltas.each { |d| missing_deltas[d] = { :value => 0.0 } }
+    #we'll put the euler angles in here
+    missing_euler = {}
+    #put 0.0 to euler angles
+    [:alpha,:beta,:gamma].each { |a| missing_euler[a] = { :value => 0.0 } }
+    #and build the values array
+    v = { :deltas => missing_deltas, :euler => missing_euler, :blackout => true }
+    return v
+  end
+end

data/lib/mamba.rb

@@ -0,0 +1,324 @@
+require "rubygems"
+require "rofl"
+require "Qt4"
+require "graph"
+#require "unprof"
+
+#oky, this will become a visualizer for large data sequences
+
+class Gui < Qt::Widget
+  
+  attr_accessor :width,:height
+  attr_accessor :x_delta,:mousex,:mousey
+  
+  def initialize(width,height,parent = nil)
+    super()
+    @width,@height = width,height
+    resize(@width,@height)
+    @lfw = 16 # legend font width
+    @tfw = 15 # timestamp font width
+    @pfw = 11 # predicate font width
+    #text will not be filled
+    #@brush = Qt::NoBrush
+    #text will be filled
+    @brush = Qt::Brush.new Qt::Color.new 0, 0, 0
+    @current_color = 0
+    #generate these deltas
+    deltas = []
+    #display these predicates
+    @predicates = [:boh, :pd, :wp, :we]
+    #graph with the data we want to visualize
+    #@graph = Graph.new "V06",deltas,@height/12
+    @graph = Graph.new "",deltas,@height/12,true #will build graph from table 'TrackerTest'
+    #max movement speed
+    @speedlimit = 20
+    #setup the rest
+    setup
+    #method doing the x scrolling for us
+    dlog "Initialized, starting active scroll loop."
+    reactive_scroll
+  end
+  
+  #setup all the stuff we need to display
+  def setup
+    #legend painter path
+    @legend = build_legend_path
+    #text painter path
+    @text = build_text_path
+    #graph painter paths
+    @graphs = setup_graph_paths
+    #now some gui specific stuff
+    setPalette(Qt::Palette.new(Qt::Color.new(250, 250, 250)))
+    setAutoFillBackground(true)
+    #cursor settings
+    @cur1 = self.cursor
+    @cur2 = Qt::Cursor.new(Qt::PointingHandCursor)
+    self.mouseTracking = true
+    #used for scrolling objects to the left and right
+    @xdelta,@xgoal,@xspeed = 0.0,0.0,0.0
+  end
+  
+  #build painter path for the legend
+  def build_legend_path
+    p = Qt::PainterPath.new
+    p.moveTo 0,0
+    font = Qt::Font.new "Arial", @lfw
+    p.addText @lfw,1.5*@lfw, font, "LEFT: euler angles"
+    p.addText @lfw,2*@height/12, font, "RIGHT: euler angles"
+    p.addText @lfw,5*@height/12, font, "LEFT: data"
+    p.addText @lfw,7*@height/12, font, "RIGHT: data"
+    p.addText @lfw,10*@height/12-@lfw, font, "LEFT: blackout"
+    p.addText @lfw,10*@height/12+@lfw, font, "RIGHT: blackout"
+    p.addText @lfw,11*@height/12-@lfw/2, font, "timestamps"
+    dlog "Finished legend path setup."
+    return p
+  end
+  
+  #build painter path for the text data
+  def build_text_path
+    #y to timestamps
+    ty = 11*@height/12
+    #back to left hand data
+    ypl = -5*@height/12-2*@lfw
+    #and back to right hand data
+    ypr = -3*@height/12-2*@lfw
+    tfont = Qt::Font.new "Arial", @tfw
+    pfont = Qt::Font.new "Arial", @pfw
+    every = 25 #display text every ... frames
+    current = 0
+    p = Qt::PainterPath.new
+    p.moveTo 0,0
+    @graph.points.each do |ts,hands|
+      if current >= every
+        p.addText hands[:left][:x],@lfw, tfont, "#{ts}"
+        #display the predicates
+        @predicates.each_index do |i|
+          p.addText hands[:left][:x], ypl+i*@lfw, pfont, "#{hands[:left][@predicates[i]]}"
+          p.addText hands[:right][:x], ypr+i*@lfw, pfont, "#{hands[:right][@predicates[i]]}"
+        end
+        current = 0
+      else
+        current += 1
+      end
+    end
+    dlog "Finished subtitles path setup."
+    return { :y => ty, :path => p }
+  end
+  
+  #setup the graph paths we want to paint
+  def setup_graph_paths
+    dlog "Starting graph path setup."
+    graph_paths = {}
+    #build following graphs for both hands
+    [:left,:right].each do |hand| 
+      #build painter paths for blackout graph
+      blackout = build_blackout_path(hand)
+      graph_paths[blackout[:name]] = blackout
+      dlog "Finished blackout path setup. Y: #{blackout[:y]}"
+      #build painter paths for euler angles
+      [:alpha,:beta,:gamma].each do |angle|
+        euler = build_euler_path(hand,angle)
+        graph_paths[euler[:name]] = euler
+        dlog "Finished #{euler[:name]} path setup. Y: #{euler[:y]}"
+      end
+      #build painter paths for deltas
+      @graph.deltas.each do |d|
+        delta = build_delta_path(hand,d)
+        graph_paths[delta[:name]] = delta
+        dlog "Finished #{delta[:name]} path setup. Y: #{delta[:y]}"
+      end        
+    end    
+    dlog "Finished graph path setup."
+    return graph_paths
+  end
+  
+  #build painter path for blackout graph
+  def build_blackout_path hand
+    name = "blackout_#{hand}".to_sym
+    color = Qt::Color.new(0, 0, 64) if hand.eql? :left
+    color = Qt::Color.new(64, 0, 0) if hand.eql? :right
+    #y-translation of the graph, we only need y
+    ty = 10*@height/12+@lfw/2
+    ty -= @lfw if hand.eql? :left
+    ty += @lfw if hand.eql? :right
+    path = Qt::PainterPath.new
+    path.moveTo 0,0
+    #now we construct the path
+    @graph.points.each do |ts,v|
+      unless v[hand][:blackout]        
+       path.moveTo v[hand][:x],0
+      else
+       path.lineTo v[hand][:x],0
+      end   
+    end
+    #and return the values
+    return { :y => ty, :name => name, :path => path, :color => color, :width => 2.5 }
+  end
+
+  #build painter path for euler graph
+  def build_euler_path hand,angle  
+    name = "#{angle}_#{hand}".to_sym
+    color = Qt::Color.new(255, 0, 0) if angle.eql? :alpha
+    color = Qt::Color.new(0, 255, 0) if angle.eql? :gamma
+    color = Qt::Color.new(0, 0, 255) if angle.eql? :beta
+    #y-translation of the graph, we only need y
+    ty = @height/6
+    path = Qt::PainterPath.new
+    path.moveTo 0,0
+    #now we construct the path
+    @graph.points.each do |ts,v|
+      path.lineTo v[hand][:euler][angle][:point]
+    end
+    #and return the values
+    return { :y => ty, :name => name, :path => path, :color => color }
+  end
+  
+  #build painter path for delta graph
+  def build_delta_path hand,delta   
+    name = "#{delta}_#{hand}".to_sym
+    color = Qt::Color.new(64, 0, @current_color%255) if hand.eql? :left
+    color = Qt::Color.new(@current_color%255, 0, 64) if hand.eql? :right
+    #change color for next delta
+    @current_color += 16
+    ty = 7*@height/12
+    path = Qt::PainterPath.new
+    path.moveTo 0,0
+    #now we construct the path
+    @graph.points.each do |ts,v|
+      path.lineTo v[hand][:deltas][delta][:point]
+    end
+    #and return the values
+    return { :y => ty, :name => name, :path => path, :color => color }
+  end
+  
+  #gets called when a repaint is necessary
+  def paintEvent(event)
+    paint_graphs
+    paint_text
+    paint_legend
+  end
+  
+  #outsourced graph painting
+  def paint_graphs
+    p = Qt::Painter.new(self)
+    p.setRenderHint(Qt::Painter::HighQualityAntialiasing)
+    p.setBrush Qt::NoBrush
+    @graphs.each do |name,path|
+      p.resetMatrix
+      p.translate((@width/2)-@xdelta,path[:y])
+      pen = Qt::Pen.new(Qt::SolidLine)
+      pen.setColor path[:color]
+      if path.has_key? :width
+        pen.setWidth path[:width]
+      else
+        pen.setWidth 1.5
+      end
+      p.setPen(pen)
+      p.drawPath path[:path]
+    end
+    p.end()
+  end
+
+  #outsourced text painting
+  def paint_text
+    p = Qt::Painter.new(self)
+    p.setRenderHint(Qt::Painter::HighQualityAntialiasing)
+    p.setBrush Qt::NoBrush
+    p.resetMatrix
+    p.translate((@width/2)-@xdelta,@text[:y])
+    pen = Qt::Pen.new(Qt::SolidLine)
+    pen.setWidth 2
+    p.setPen(pen)
+    p.drawPath @text[:path]
+    p.end()
+  end
+  
+  #outsourced legend painting
+  def paint_legend
+    p = Qt::Painter.new(self)
+    p.setRenderHint(Qt::Painter::HighQualityAntialiasing)
+    p.resetMatrix
+    p.translate(0,0)
+    p.setBrush @brush
+    pen = Qt::Pen.new(Qt::SolidLine)
+    pen.setWidth 1
+    p.setPen(pen)
+    p.drawPath @legend
+    p.end()
+  end
+
+  #mouse press event
+  def mousePressEvent event
+    if event.buttons == Qt::RightButton
+    elsif event.buttons == Qt::LeftButton
+      #update
+    end
+  end
+  
+  #a mouse move event
+  def mouseMoveEvent event
+    @mousex,@mousey = event.x,event.y
+  end
+  
+  #ruby thread test
+  def reactive_scroll
+    fps = 60.0 #frames per second we attempt to compute
+    tts = 0.0 #time to sleep
+    last_time = Time.now
+    Thread.new do
+      loop do 
+        tts = 1.0/fps - (Time.now-last_time) 
+        sleep tts if tts > 0
+        unless @mousex.nil?
+          scroll_x 
+          smooth_delta
+          if @xspeed.abs > 1 
+            #are we speeding?
+            if @xspeed < -1.0*@speedlimit
+              @xspeed = -1.0*@speedlimit
+              @xgoal = @xdelta
+            end
+            if @xspeed > @speedlimit
+              @xspeed = @speedlimit 
+              @xgoal = @xdelta
+            end
+            #new delta
+            @xdelta = (@xdelta + @xspeed).to_i
+            update
+          end
+        end
+        last_time = Time.now
+      end
+    end
+  end
+  
+  #scroll on the x_axis if necessary
+  def scroll_x
+    damper = 10
+    #need some kind of zone that triggers scrolling: 1/4 width left and right
+    if @mousex < @width/4
+      @xgoal += (@mousex - @width/4)/damper  
+    end
+    if @mousex > 3*@width/4
+      @xgoal += (@mousex - 3*@width/4)/damper
+    end
+  end
+  
+  #method that smoothes the scroll deltas over time
+  def smooth_delta
+    @xspeed = (@xgoal-@xdelta)*0.05
+  end
+end
+
+#start the qt application
+app = Qt::Application.new(ARGV)
+gui = Gui.new(1200,760)
+#dirty qt timer magic to make ruby threads work
+block=Proc.new{ Thread.pass }
+timer=Qt::Timer.new(gui)
+invoke=Qt::BlockInvocation.new(timer, block, "invoke()")
+Qt::Object.connect(timer, SIGNAL("timeout()"), invoke, SLOT("invoke()"))
+timer.start(12.5) #in millis
+#end of dirty timer hack
+gui.show()
+app.exec()

data/tests/generate_testdata.rb

@@ -0,0 +1,150 @@
+=begin
+  This class is used to generate test Tracker-Data to validate and debug
+  the other software.
+=end
+
+require "rubygems"
+require "narray"
+require "sequel"
+require "rofl"
+
+#connect to the database
+DB = Sequel.connect(:adapter=>'mysql', :host=>'localhost', :database=>'database', :user=>'user', :password=>'password')
+
+class TrackerTestDataGenerator
+  
+  def initialize
+    tablename = "TrackerTest"
+    #drop old test tables
+    DB.drop_table tablename.to_sym
+    #create new table for test data
+    create_test_table tablename
+    #our access to the db is here
+    @rows = DB[tablename.to_sym]
+    @freq = 50.0 #data frequency in Hz
+    length = 60.0 #in seconds
+    generate_test_data length
+    ilog "Generated #{@rows.count} test frames."
+  end
+  
+  #this method will generate some easy to debug test tracker data for Neck,Left Hand,Right Hand
+  def generate_test_data length
+    chunk = 1.0 / @freq #frame distance in seconds
+    frames = length * @freq #number of frames per identifier
+    #now we generate the test frames
+    (0..frames).each do |i|
+      timestamp = i*chunk
+      m = NMatrix.float(4,4).unit
+      #identifier specific changes
+      write_matrix_to_db timestamp,"Neck",m
+      write_matrix_to_db timestamp,"Left_Hand",get_left_hand(i)
+      write_matrix_to_db timestamp,"Right_Hand",get_right_hand(i)
+    end
+  end
+
+  #generate test data for left hand
+  def get_left_hand index  
+    m = NMatrix.float(4,4).unit
+    #Left hand changes to position vector
+    m[3,0] = -1 #x
+    m[3,1] = 0.2 #y
+    m[3,2] = -0.5 #z
+    #make potential BOH point to BAB
+    rot_x = x_rotation_matrix -0.5 #rotate 90 degrees around x axis
+    m *= rot_x
+    #and now rotate around BOH axis at 1Hz
+    rot_y = y_rotation_matrix(-index*(2.0/@freq))
+    m *= rot_y
+    return m
+  end
+  
+  #generate test data for right hand
+  def get_right_hand index  
+    m = NMatrix.float(4,4).unit
+    #Right hand changes to position vector
+    m[3,0] = 1 #x
+    m[3,1] = 0.2 #y
+    m[3,2] = -0.5 #z
+    #make potential BOH point to BAB
+    rot_x = x_rotation_matrix -0.5 #rotate 90 degrees around x axis
+    m *= rot_x
+    #and now rotate around BOH axis at 1Hz
+    rot_y = y_rotation_matrix(index*(2.0/@freq))
+    m *= rot_y
+    return m
+  end
+  
+  #get a rotation matrix for a rotation around the x axis
+  def x_rotation_matrix radian
+    m = NMatrix.float(4,4).unit
+    m[1,1] = Math.cos(radian*Math::PI)
+    m[1,2] = Math.sin(radian*Math::PI)
+    m[2,1] = Math.sin(radian*Math::PI)*(-1.0)
+    m[2,2] = Math.cos(radian*Math::PI)
+    return m
+  end
+  
+  #get a rotation matrix for a rotation around the y axis
+  def y_rotation_matrix radian
+    m = NMatrix.float(4,4).unit
+    m[0,0] = Math.cos(radian*Math::PI)
+    m[0,2] = Math.sin(radian*Math::PI)*(-1.0)
+    m[2,0] = Math.sin(radian*Math::PI)
+    m[2,2] = Math.cos(radian*Math::PI)
+    return m
+  end
+  
+  #get a rotation matrix for a rotation around the z axis
+  def z_rotation_matrix radian
+    m = NMatrix.float(4,4).unit
+    m[0,0] = Math.cos(radian*Math::PI)
+    m[0,1] = Math.sin(radian*Math::PI)
+    m[1,0] = Math.sin(radian*Math::PI)*(-1.0)
+    m[1,1] = Math.cos(radian*Math::PI)
+    return m
+  end
+  
+  #write matrix to db    
+  def write_matrix_to_db timestamp,identifier,matrix   
+    m = matrix.transpose #matrix data in the db are transposed
+    #insert the matrix into the db
+    @rows.insert(:timestamp => timestamp, :identifier => identifier,
+                 :xpos => m[0,3]*1000,:ypos => m[1,3]*1000,:zpos => m[2,3]*1000,             
+                 :m00 => m[0,0],:m10 => m[1,0],:m20 => m[2,0],:m30 => m[3,0],
+                 :m01 => m[0,1],:m11 => m[1,1],:m21 => m[2,1],:m31 => m[3,1],
+                 :m02 => m[0,2],:m12 => m[1,2],:m22 => m[2,2],:m32 => m[3,2],
+                 :m03 => m[0,3],:m13 => m[1,3],:m23 => m[2,3],:m33 => m[3,3])
+  end
+
+  #create table to store test data into
+  def create_test_table tablename
+    DB.create_table tablename.to_sym do
+      primary_key :index
+      String      :identifier
+      Double      :timestamp
+      Float       :xpos
+      Float       :ypos
+      Float       :zpos
+      #unity matrix is default
+      Float       :m00, :default => 1.0
+      Float       :m01, :default => 0.0
+      Float       :m02, :default => 0.0
+      Float       :m03, :default => 0.0
+      Float       :m10, :default => 0.0
+      Float       :m11, :default => 1.0
+      Float       :m12, :default => 0.0
+      Float       :m13, :default => 0.0
+      Float       :m20, :default => 0.0
+      Float       :m21, :default => 0.0
+      Float       :m22, :default => 1.0
+      Float       :m23, :default => 0.0
+      Float       :m30, :default => 0.0
+      Float       :m31, :default => 0.0
+      Float       :m32, :default => 0.0
+      Float       :m33, :default => 1.0
+    end
+  end
+end
+
+#generate some test data
+test = TrackerTestDataGenerator.new

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification 
+name: pangdudu-mamba
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- pangdudu
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-27 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: pangdudu-rofl
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: sequel
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: sequel_core
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: sequel_model
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: mysql
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: narray
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: ruby-opengl
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: qt-ruby tool for ART tracker data time series analysis.
+email: pangdudu@github
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- lib/mamba.rb
+- lib/graph.rb
+- lib/b1trackerdata/b1_data_parser.rb
+- lib/b1trackerdata/openglviewer.rb
+- tests/generate_testdata.rb
+has_rdoc: true
+homepage: http://github.com/pangdudu/mamba
+licenses: 
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: a ruby-qt ART tracker data analysis tool
+test_files: []
+