motel 0.2

data/conf/amqp.yml

@@ -0,0 +1,13 @@
+# motel amqp config
+
+production:
+  broker: 127.0.0.1
+  port: 5672
+
+development:
+  broker: 127.0.0.1
+  port: 5672
+
+test:
+  broker: 127.0.0.1
+  port: 5672

data/conf/database.yml

@@ -0,0 +1,41 @@
+# motel database config
+#
+# Fedora Install Instructions:
+#   sudo yum install ruby-postgres postgresql-server
+#   sudo /sbin/service postgresql initdb
+#   sudo /sbin/service postgresql start
+#   sudo su - postgres
+#   createdb motel
+#   $   psql motel
+#   $-# CREATE USER motel WITH PASSWORD 'motel';
+#   $-# GRANT ALL PRIVILEGES ON DATABASE motel to motel;
+#   $-# CREATE DATABASE motel_test;
+#   $-# GRANT ALL PRIVILEGES ON DATABASE motel_test to motel;
+#   $-# CREATE DATABASE motel_development;
+#   $-# GRANT ALL PRIVILEGES ON DATABASE motel_development to motel;
+#   $-# \q
+#   $   exit
+
+production:
+  adapter: postgresql
+  database: motel
+  username: motel
+  password: motel
+  host: localhost
+  pool: 20
+
+development:
+  adapter: postgresql
+  database: motel_development
+  username: motel
+  password: motel
+  host: localhost
+  pool: 20
+
+test:
+  adapter: postgresql
+  database: motel_test
+  username: motel
+  password: motel
+  host: localhost
+  pool: 20

data/db/migrate/001_create_locations_and_movement_strategies.rb

@@ -0,0 +1,45 @@
+# creates the locations and movement_strategies tables
+#
+# Copyright (C) 2009 Mohammed Morsi <movitto@yahoo.com>
+# See COPYING for the License of this software
+
+require 'motel'
+
+# ActiveRecord::Migration 001
+class CreateLocationsAndMovementStrategies < ActiveRecord::Migration
+  def self.up
+
+     create_table :movement_strategies do |t|
+        t.string  :type,        :null => false, :size => 50
+        t.float   :step_delay,  :null => false
+     end
+
+     create_table :locations do |t|
+        t.float :x, :default => nil
+        t.float :y, :default => nil
+        t.float :z, :default => nil
+        t.integer :movement_strategy_id, :null => false
+
+        t.integer :parent_id, :default => nil
+     end
+
+     execute "alter table locations add constraint fk_location_parent
+              foreign key(parent_id) references locations(id)"
+
+     execute "alter table locations add constraint fk_location_movement_strategy
+              foreign key(movement_strategy_id) references movement_strategies(id)"
+
+     execute "alter table locations add constraint root_or_child 
+              check (parent_id IS NULL AND x IS NULL AND y IS NULL AND z IS NULL OR
+                     parent_id IS NOT NULL AND x IS NOT NULL AND y IS NOT NULL AND z IS NOT NULL)"
+
+
+     # create the first / default movement strategy 'stopped'
+     Motel::Models::Stopped.new(:step_delay => 5).save!
+  end
+
+  def self.down
+     drop_table :locations
+     drop_table :movement_strategies
+  end
+end

data/db/migrate/002_create_linear_movement_strategy.rb

@@ -0,0 +1,23 @@
+# creates the neccessary fields for the Linear MovementStrategy
+#
+# Copyright (C) 2009 Mohammed Morsi <movitto@yahoo.com>
+# See COPYING for the License of this software
+
+require 'motel'
+
+# ActiveRecord::Migration 002
+class CreateLinearMovementStrategy < ActiveRecord::Migration
+  def self.up
+     add_column :movement_strategies, :speed,              :float
+     add_column :movement_strategies, :direction_vector_x, :float
+     add_column :movement_strategies, :direction_vector_y, :float
+     add_column :movement_strategies, :direction_vector_z, :float
+  end
+
+  def self.down
+     remove_column :movement_strategies, :speed
+     remove_column :movement_strategies, :direction_vector_x
+     remove_column :movement_strategies, :direction_vector_y
+     remove_column :movement_strategies, :direction_vector_z
+  end
+end

data/db/migrate/003_create_elliptical_movement_strategy.rb

@@ -0,0 +1,52 @@
+# creates the neccessary fields for the Elliptical MovementStrategy
+#
+# Copyright (C) 2009 Mohammed Morsi <movitto@yahoo.com>
+# See COPYING for the License of this software
+
+require 'motel'
+
+# ActiveRecord::Migration 003
+class CreateEllipticalMovementStrategy < ActiveRecord::Migration
+  def self.up
+     # we already have speed from linear
+     #add_column :movement_strategies, :speed,              :float
+
+     # relative_to field indicates what type of parent
+     # this movement stategy is relative to, for Ellilptical
+     # strategies, this can be 'center' indicating the parent
+     # is the center of the ellipse or 'foci' indicating the
+     # parent is on of the ellipse foci's
+     add_column :movement_strategies, :relative_to, :string, :size => 50
+
+     # eccentricity of the ellipse
+     add_column :movement_strategies, :eccentricity, :float
+
+     # semi_latus_rectum of the ellipse
+     add_column :movement_strategies, :semi_latus_rectum, :float
+
+     # unit direction vector of the major axis
+     add_column :movement_strategies, :direction_major_x, :float
+     add_column :movement_strategies, :direction_major_y, :float
+     add_column :movement_strategies, :direction_major_z, :float
+
+     # unit direction vector of the minor axis
+     add_column :movement_strategies, :direction_minor_x, :float
+     add_column :movement_strategies, :direction_minor_y, :float
+     add_column :movement_strategies, :direction_minor_z, :float
+  end
+
+  def self.down
+     # remove in linear strategy
+     #remove_column :movement_strategies, :speed
+
+     remove_column :movement_strategies, :relative_to
+     remove_column :movement_strategies, :eccentricity
+     remove_column :movement_strategies, :semi_latus_rectum
+     remove_column :movement_strategies, :direction_major_x
+     remove_column :movement_strategies, :direction_major_y
+     remove_column :movement_strategies, :direction_major_z
+     remove_column :movement_strategies, :direction_minor_x
+     remove_column :movement_strategies, :direction_minor_y
+     remove_column :movement_strategies, :direction_minor_z
+  end
+end

data/lib/motel/common.rb

@@ -0,0 +1,54 @@
+# common & useful methods and other.
+#
+# Things that don't fit elsewhere
+#
+# Copyright (C) 2009 Mohammed Morsi <movitto@yahoo.com>
+# See COPYING for the License of this software
+
+module Motel
+
+# generate a random id
+def gen_uuid
+  ["%02x"*4, "%02x"*2, "%02x"*2, "%02x"*2, "%02x"*6].join("-") %
+      Array.new(16) {|x| rand(0xff) }
+end
+
+# normalize a vector if not normal already, 
+# eg divide each component x,y,z by the 
+# vector length and return them
+def normalize(x,y,z)
+  return x,y,z if x.nil? || y.nil? || z.nil?
+
+  l = Math.sqrt(x**2 + y**2 + z**2)
+  if l != 1
+    x /= l
+    y /= l
+    z /= l
+  end
+  return x,y,z
+end
+
+# determine if two vectors are orthogonal
+def orthogonal?(x1,y1,z1, x2,y2,z2)
+  return false if x1.nil? || y1.nil? || z1.nil? || x2.nil? || y2.nil? || z2.nil?
+  return (x1 * x2 + y1 * y2 + z1 * z2).abs == 0
+end
+
+end # module Motel
+
+# provide floating point rounding mechanism
+class Float
+  def round_to(precision)
+     return nil if precision <= 0
+     return (self * 10 ** precision).round.to_f / (10 ** precision)
+  end
+end
+
+# try to find key equal to method, returning value if found
+#class Hash  
+#  def method_missing(method, *params)  
+#    method = method.to_sym  
+#    return self[method] if self.keys.collect{ |k| k.to_sym }.include?(method)  
+#    super  
+#  end  
+#end

data/lib/motel/loader.rb

@@ -0,0 +1,47 @@
+# The Loader class definition
+#
+# Copyright (C) 2009 Mohammed Morsi <movitto@yahoo.com>
+# See COPYING for the License of this software
+
+require 'motel/runner'
+
+module Motel
+
+# A Loader loads instances of Location from the db
+# according to any specified conditions, instantiates
+# a new Runner for each of those locations and returns them
+class Loader
+  
+ public
+
+  # Default class constructor
+  def initialize
+  end
+
+  # Static member to load all locations that match a specified 
+  # condition (ala activerecord) and add it to the singleton Runner
+  # instance using it to run the locations.
+  def self.Load(conditions = 'parent_id IS NULL')
+     locations = Location.find(:all, :conditions => conditions)
+     return nil if locations.size == 0
+
+     locations.each { |location|
+       run_location(location)
+     }
+     return locations.size
+  end
+
+ private
+
+  # Static internal helper method that adds a location and 
+  # all its children to the Runner
+  def self.run_location(location)
+    Runner.get.run location
+    location.children.each { |child|
+       run_location child
+    }
+  end
+
+end
+
+end

data/lib/motel/models/elliptical.rb

@@ -0,0 +1,259 @@
+# The Elliptcial MovementStrategy model definition
+#
+# Copyright (C) 2009 Mohammed Morsi <movitto@yahoo.com>
+# See COPYING for the License of this software
+
+require 'motel/common'
+require 'motel/models/movement_strategy'
+
+module Motel
+module Models
+
+# The Elliptical MovementStrategy moves a location
+# on an elliptical path described by major/minor 
+# axis direction vectors, and an eccentricity /
+# semi_latus_rectum. The path equation will 
+# also depend on the value of the relative_to
+# field indicating if the parent location 
+# is the center or a foci of the ellipse.
+# Lastly a speed value is required indicating the
+# angular velocity of the location.
+class Elliptical < MovementStrategy
+
+   # Elliptical MovementStrategy must specify x,y,z components of 
+   # the major and minor axis direction vectors
+   validates_presence_of [:direction_major_x, 
+                          :direction_major_y, 
+                          :direction_major_z,
+                          :direction_minor_x, 
+                          :direction_minor_y, 
+                          :direction_minor_z]
+
+   # make sure the unit direction vectors are normal
+   before_validation :normalize_direction_vectors
+   def normalize_direction_vectors
+      dx, dy, dz =
+         normalize(direction_major_x, direction_major_y, direction_major_z)
+      self.direction_major_x, self.direction_major_y, self.direction_major_z = dx, dy, dz
+
+      dx, dy, dz =
+         normalize(direction_minor_x, direction_minor_y, direction_minor_z)
+      self.direction_minor_x, self.direction_minor_y, self.direction_minor_z = dx, dy, dz
+   end
+
+
+   # Elliptical MovementStrategy must specify the angular velocity
+   # at which the location is moving
+   validates_presence_of      :speed
+   validates_numericality_of  :speed,
+      :greater_than_or_equal_to => 0,
+      :less_than_or_equal_to    => 2 * Math::PI
+
+   # the eccentricity of the ellipse
+   validates_presence_of     :eccentricity
+   validates_numericality_of :eccentricity,
+      :greater_than_or_equal_to => 0,
+      :less_than_or_equal_to    => 1
+
+   def e
+     eccentricity
+   end
+   def e=(v)
+    eccentricity= v
+   end
+
+   # the semi_latus_rectum of the ellipse
+   validates_presence_of :semi_latus_rectum
+   validates_numericality_of :semi_latus_rectum,
+      :greater_than_or_equal_to => 0
+
+   def p
+     semi_latus_rectum
+   end
+   def p=(v)
+     semi_latus_rectum = v
+   end
+
+   # the possible relative_to values
+   RELATIVE_TO_CENTER = "center"
+   RELATIVE_TO_FOCI   = "foci"
+
+   # must be relative to a parent center or foci
+   validates_presence_of :relative_to
+   validates_inclusion_of :relative_to,
+     :in => [ RELATIVE_TO_CENTER, RELATIVE_TO_FOCI ]
+
+   # ActiveRecord::Base::validate
+   def validate
+      errors.add("direction vectors must be orthogonal") unless orthogonal?(direction_major_x, direction_major_y, direction_major_z,
+                                                                            direction_minor_x, direction_minor_y, direction_minor_z)
+   end
+
+   # convert non-nil elliptical movement strategy attributes to a hash
+   def to_h
+     result = {}
+     result[:speed] = speed unless speed.nil?
+     result[:eccentricity] = eccentricity unless eccentricity.nil?
+     result[:semi_latus_rectum] = semi_latus_rectum unless semi_latus_rectum.nil?
+     result[:relative_to] = relative_to unless relative_to.nil?
+     result[:direction_major_x] = direction_major_x unless direction_major_x.nil?
+     result[:direction_major_y] = direction_major_y unless direction_major_y.nil?
+     result[:direction_major_z] = direction_major_z unless direction_major_z.nil?
+     result[:direction_minor_x] = direction_minor_x unless direction_minor_x.nil?
+     result[:direction_minor_y] = direction_minor_y unless direction_minor_y.nil?
+     result[:direction_minor_z] = direction_minor_z unless direction_minor_z.nil?
+     return result
+   end
+
+   # convert elliptical movement strategy to a string
+   def to_s
+     super + "; speed:#{speed}; eccentricity:#{eccentricity}; semi_latus_rectum:#{semi_latus_rectum}; relative_to:#{relative_to}; " + 
+               "direction_major_x:#{direction_major_x}; direction_major_y:#{direction_major_y}; direction_major_z:#{direction_major_z}; " +
+               "direction_minor_x:#{direction_minor_x}; direction_minor_y:#{direction_minor_y}; direction_minor_z:#{direction_minor_z}"
+   end
+
+   # Motel::Models::MovementStrategy::move
+   def move(location, elapsed_seconds)
+      # make sure this movement strategy is valid
+      unless valid?
+         Logger.warn "elliptical movement strategy not valid, not proceeding with move"
+         return
+      end
+
+      # make sure location is on ellipse
+      unless location_valid? location
+         cx,cy,cz = closest_coordinates location
+         Logger.warn "location #{location} not on ellipse, the closest location is #{cl}, not proceeding with move"
+         return
+      end
+
+     Logger.debug "moving location #{location} via elliptical movement strategy"
+
+     # calculate distance moved and update x,y,z accordingly
+     distance = speed * elapsed_seconds
+
+     nX,nY,nZ = coordinates_from_theta(theta(location) + distance)
+     location.x = nX
+     location.y = nY
+     location.z = nZ
+
+     Logger.debug "moved location #{location} via elliptical movement strategy"
+   end
+
+  private
+
+    ### internal helper movement methods
+
+    # return the a,b intercepts of the ellipse
+    # p = a(1 - e^2) = b^2 / a
+    # e = sqrt(1 - (b/a)^2)
+    def intercepts
+      a = p / (1 - e**2)
+      b = Math.sqrt(p * a)
+      return a,b
+    end
+
+    # return the linear eccentricity of the ellipse
+    # le = sqrt(a^2 - b^2)
+    def linear_eccentricity 
+      a,b = intercepts
+      Math.sqrt(a**2 - b**2);
+    end
+
+    # return the coordinates of the center position
+    # C = (-direction_major) * le
+    def center
+      return 0,0,0 if relative_to == RELATIVE_TO_CENTER
+
+      a,b = intercepts
+      le  = linear_eccentricity
+
+      centerX = -1 * direction_major_x * le; 
+      centerY = -1 * direction_major_y * le; 
+      centerZ = -1 * direction_major_z * le;
+      return centerX, centerY, centerZ
+    end
+
+    # return the coordinates of a focus position
+    # F = direction_major * le
+    def focus
+      return 0,0,0 if relative_to == RELATIVE_TO_FOCI
+
+      a,b = intercepts
+      le  = linear_eccentricity
+
+      focusX = direction_major_x * le; 
+      focusY = direction_major_y * le; 
+      focusZ = direction_major_z * le;
+      return focusX, focusY, focusZ
+    end
+
+    # return the origin centered coordiates of a location
+    def origin_centered_coordinates(location)
+      cX,cY,cZ = center
+      return location.x - cX,
+             location.y - cY,
+             location.z - cZ
+    end
+
+    # return the theta corresponding to the position of a 
+    # location on the elliptical path.
+    #
+    #  derived formula for theta from x,y,z elliptical path equations (see below) and linear transformations:
+    #  theta = acos((minY * (x-cX) - minX * (y-cY))/(a*(minY * majX - minX * majY)))
+    def theta(location)
+      a,b = intercepts
+      ocX,ocY,ocZ = origin_centered_coordinates location
+
+      t = (direction_minor_y * ocX - direction_minor_x * ocY) /
+           (a * (direction_minor_y * direction_major_x - direction_minor_x * direction_major_y))
+      t= 1.0 if(t>1.0) 
+      theta = Math.acos(t)
+
+      # determine if current point is in negative quadrants of min axis coordinate system
+      below = ocY < ((direction_minor_x * ocX + direction_minor_z * ocZ) / (-direction_minor_y)) 
+
+      # adjust to compenate for acos loss if necessary
+      theta = (3 * Math::PI / 2) + (Math::PI / 2 - theta) if (below) 
+
+      return theta;
+    end
+
+    # calculate the x,y,z coordinates of a location on the elliptical
+    # path given its theta
+    #
+    # Elliptical path equation:
+    # [x,y,z] = a * cos(theta) * maj + b * sin(theta) * min 
+    #   (if centered at origin)
+    def coordinates_from_theta(theta)
+       a,b      = intercepts
+       cX,cY,cZ = center
+
+       x = cX + a * Math.cos(theta) * direction_major_x + b * Math.sin(theta) * direction_minor_x
+       y = cY + a * Math.cos(theta) * direction_major_y + b * Math.sin(theta) * direction_minor_y
+       z = cZ + a * Math.cos(theta) * direction_major_z + b * Math.sin(theta) * direction_minor_z
+       return x,y,z
+    end
+
+   # return x,y,z coordinates of the closest point on the ellipse to the given location
+   def closest_coordinates(location)
+      t = theta location
+
+      return nil if t.nan?
+
+      return coordinates_from_theta(t)
+   end
+
+   # return boolean indicating if the given location is on the ellipse or not
+   def location_valid?(location)
+      x,y,z = closest_coordinates(location)
+
+      return (x - location.x).round_to(4) == 0 &&
+             (y - location.y).round_to(4) == 0 &&
+             (z - location.z).round_to(4) == 0
+   end
+
+end
+
+end # module Models
+end # module Motel

data/lib/motel/models/linear.rb

@@ -0,0 +1,76 @@
+# The Linear MovementStrategy model definition
+#
+# Copyright (C) 2009 Mohammed Morsi <movitto@yahoo.com>
+# See COPYING for the License of this software
+
+require 'motel/common'
+require 'motel/models/movement_strategy'
+
+module Motel
+module Models
+
+# The Linear MovementStrategy moves a location
+# in a linear manner as defined by a 
+# unit direction vector and a floating point
+# speed
+class Linear < MovementStrategy
+
+   # Linear MovementStrategy must specify x,y,z components of 
+   # a unit direction vector
+   validates_presence_of [:direction_vector_x, 
+                          :direction_vector_y, 
+                          :direction_vector_z]
+
+   # make sure the unit direction vector is normal
+   before_validation :normalize_direction_vector
+   def normalize_direction_vector
+      dx, dy, dz =
+         normalize(direction_vector_x, direction_vector_y, direction_vector_z)
+      self.direction_vector_x, self.direction_vector_y, self.direction_vector_z = dx, dy, dz
+   end
+
+
+   # Linear MovementStrategy must specify the speed
+   # at which the location is moving
+   validates_presence_of :speed
+   validates_numericality_of :speed,
+      :greater_than_or_equal_to => 0
+
+   # Motel::Models::MovementStrategy::move
+   def move(location, elapsed_seconds)
+     unless valid?
+       Logger.warn "linear movement strategy not valid, not proceeding with move"
+       return
+     end
+
+     Logger.debug "moving location #{location.to_s} via linear movement strategy"
+
+     # calculate distance and update x,y,z accordingly
+     distance = speed * elapsed_seconds
+
+     location.x += distance * direction_vector_x
+     location.y += distance * direction_vector_y
+     location.z += distance * direction_vector_z
+
+     Logger.debug "moved location #{location} via linear movement strategy"
+   end
+
+   # convert non-nil linear movement strategy attributes to a hash
+   def to_h
+     result = {}
+     result[:speed] = speed unless speed.nil?
+     result[:direction_vector_x] = direction_vector_x unless direction_vector_x.nil?
+     result[:direction_vector_y] = direction_vector_y unless direction_vector_y.nil?
+     result[:direction_vector_z] = direction_vector_z unless direction_vector_z.nil?
+     return result
+   end
+
+   # convert linear movement strategy to a string
+   def to_s
+     super + "; speed: #{speed}; direction_vector_x:#{direction_vector_x}; " + 
+             "direction_vector_y:#{direction_vector_y}; direction_vector_z:#{direction_vector_z}"
+   end
+end
+
+end # module Models
+end # module Motel