kamelopard 0.0.11 → 0.0.12

data/lib/kamelopard.rb

@@ -3,3 +3,4 @@ require 'kamelopard/helpers'
 require 'kamelopard/geocode'
 require 'kamelopard/function'
 require 'kamelopard/function_paths'
+require 'kamelopard/multicam'

data/lib/kamelopard/classes.rb

@@ -108,6 +108,15 @@ module Kamelopard
     def Kamelopard.convert_coord(a)    # :nodoc:
         a = a.to_s.upcase.strip.gsub(/\s+/, '')
 
+        if a =~ /^[+-]?\d+(\.\d+)?$/ then
+            # coord needs no transformation
+            return a.to_f
+        elsif a =~ /^[+-]?\d+\.\d+E?-?\d+/ then
+            # Scientific notation
+            return a.to_f
+        end
+        p a
+
         mult = 1
         if a =~ /^-/ then
             mult *= -1
@@ -121,10 +130,7 @@ module Kamelopard
         a = a.sub /[NESW]$/, ''
         a = a.strip
 
-        if a =~ /^\d+(\.\d+)?$/ then
-            # coord needs no transformation
-            1
-        elsif a =~ /^\d+D\d+M\d+(\.\d+)?S$/ then
+        if a =~ /^\d+D\d+M\d+(\.\d+)?S$/ then
             # coord is in dms
             p = a.split /[D"']/
             a = p[0].to_f + (p[2].to_f / 60.0 + p[1].to_f) / 60.0
@@ -143,7 +149,7 @@ module Kamelopard
         # check that it's within range
         a = a.to_f * mult
         raise "Coordinate #{a} out of range" if a > 180 or a < -180
-        return a
+        return a.to_f
     end
 
     # Helper function for altitudeMode / gx:altitudeMode elements
@@ -629,11 +635,13 @@ module Kamelopard
         end
 
         def roll
+            # The roll element doesn't exist in LookAt objects
             raise "The roll element is part of Camera objects, not LookAt objects"
         end
 
-        def roll=
+        def roll=(a)
             # The roll element doesn't exist in LookAt objects
+            raise "The roll element is part of Camera objects, not LookAt objects"
         end
     end
 

data/lib/kamelopard/function.rb

@@ -14,7 +14,7 @@ module Kamelopard
     module Functions
 
         # Abstract class representing a one-dimensional function
-        class Function1D
+        class Function
             # min and max describe the function's domain. Values passed to
             # get_value will only range from 0 to 1; the actual value
             # calculated will be mapped to a percentage of that domain.
@@ -42,7 +42,7 @@ module Kamelopard
             end
 
             def compose=(f)
-                raise "Can only compose another one-dimensional function" unless f.kind_of? Function1D or f.nil?
+                raise "Can only compose another function" unless f.kind_of? Function or f.nil?
                 @compose = f
             end
 
@@ -57,7 +57,7 @@ module Kamelopard
             end
 
             #def append(f)
-            #    raise "Can only append another one-dimensional function" unless f.kind_of? Function1D or f.nil?
+            #    raise "Can only append another one-dimensional function" unless f.kind_of? Function or f.nil?
             #    print STDERR "WARNING: append() isn't actually implemented" unless f.nil?
             #    # XXX
             #    # Gotta implement this. The idea is to have one function for the first
@@ -74,9 +74,29 @@ module Kamelopard
             end
 
             def self.interpolate(a, b)
-                # Creates a new Function1D object between points A and B
+                # Creates a new Function object between points A and B
                 raise "Override this method before calling it, please"
             end
+        end   ## End of Function class
+
+        # get_value and run_function return a single scalar value 
+        class Function1D < Function
+            def compose=(f)
+                raise "Can only compose another one-dimensional function" unless f.kind_of? Function1D or f.nil?
+                @compose = f
+            end
+
+        end
+
+        # get_value and run_function return an array of values
+        class FunctionMultiDim < Function
+            attr_reader :ndims
+
+            def compose=(f)
+                raise "Can only compose another #{@ndims}-dimensional function" unless (f.kind_of? FunctionMultiDim and @ndims = f.ndims) or f.nil?
+                @compose = f
+            end
+
         end
 
         # Represents a cubic equation of the form c3 * x^3 + c2 * x^2 + c1 * x + c0
@@ -105,7 +125,7 @@ module Kamelopard
                 c0 = m[0,3]
                 return Cubic.new(c3, c2, c1, c0, min, max)
             end
-        end
+        end  ## End of Cubic class
 
         # Describes a quadratic equation
         class Quadratic < Cubic
@@ -149,8 +169,11 @@ module Kamelopard
                 return Constant.new((b.to_f - a.to_f) / 0.0)
             end
         end
-    end
-end 
+    end  ## End of Functions sub-module
+end  ## End of Kamelopard module
+
+## Example uses
+
 # include Kamelopard::Functions
 # 
 # l = Line.new 1.0, 0.0

data/lib/kamelopard/function_paths.rb

@@ -13,7 +13,7 @@ module Kamelopard
     #   points: The number of points in the series
     #   hash: Values used to create the hash, which creates the point in the
     #   series. Keys in this hash include:
-    #     latitude, longitude, altitude, heading, tilt, roll, range, duration, altitudeMode, extrude
+    #     Any option suitable for the make_view_from() function
     #       These can be constant numbers, Proc objects, or Function1D objects.
     #       The latter two will be called once for each point in the series.
     #       Proc objects will be passed the number of the point they're
@@ -21,7 +21,7 @@ module Kamelopard
     #       created for this point. "duration" represents the time in seconds
     #       spent flying from the last point to this one.
     #     callback
-    #       This Proc object, if defined, will be called after the above hash
+    #       This Proc object, if defined, will be called after the other hash
     #       keys have been calculated. It gets passed the number of the point,
     #       and the current value of the hash for this point. It can modify and
     #       return that hash as needed.
@@ -34,11 +34,33 @@ module Kamelopard
     #       If set, a placemark object will be created at this point
     #     no_flyto
     #       If set, on flyto objects will be created
-
+    #     multidim
+    #       An array of hashes. Each array element is an array, containing two
+    #       values. The first is associated with a FunctionMultiDim class
+    #       representing a multidimensional function. The second is an array of
+    #       symbols and nils. Valid symbols include any of the possible
+    #       make_function_path options, except :multidim. At execution, the
+    #       FunctionMultiDim will be evaluated, returning an array of values.
+    #       The symbols in the :vals array will be assigned the returned value
+    #       corresponding to their position in the :vals array. For instance,
+    #       assume the following :multidim argument
+    #          [ { :func => myFunc, :vals = [:latitude, :longitude, nil, :altitude]} ]
+    #       When myFunc is evaluated, assume it returns [1, 2, 3, 4, 5]. Thus,
+    #       :latitude will be 1, :longitude 2, and so on. Because :vals[2] is
+    #       nil, the corresponding element in the results of myFunc will be
+    #       ignored. Also, given that :vals contains four values whereas myFunc
+    #       returned 5, the unallocated final myFunc value will also be
+    #       ignored.
+    #    NOTE ON PROCESSING ORDER
+    #       Individually specified hash options are processed first, followed by
+    #       :multidim. So hash options included directly as
+    #       well as in a :multidim :vals array will take the value from
+    #       :multidim. make_function_path yields to code blocks last, after all
+    #       other assignment.
     def make_function_path(points = 10, options = {})
 
         def val(a, b, c) # :nodoc:
-            if a.kind_of? Function1D then
+            if a.kind_of? Function then
                 return a.get_value(c)
             elsif a.kind_of? Proc then
                 return a.call(b, a)
@@ -47,50 +69,92 @@ module Kamelopard
             end
         end
 
-        result_points = []
+        views = []
+        placemarks = []
 
         callback_value = nil
         i = 0
         while (i <= points)
             p = i.to_f / points.to_f
-            hash = {
-                :latitude => val(options[:latitude], i, p),
-                :longitude => val(options[:longitude], i, p),
-                :altitude => val(options[:altitude], i, p),
-                :heading => val(options[:heading], i, p),
-                :tilt => val(options[:tilt], i, p),
-                :altitudeMode => val(options[:altitudeMode], i, p),
-                :extrude => val(options[:extrude], i, p),
-            }
+            hash = {}
+            [ :latitude, :longitude, :altitude, :heading,
+              :tilt, :altitudeMode, :extrude, :when,
+              :roll, :range, :pause, :begin, :end, :show_placemarks,
+              :no_flyto, :pause
+            ].each do |k|
+                if options.has_key? k then
+                    hash[k] = val(options[k], i, p)
+                end
+            end
 
             hash[:show_placemarks] = options[:show_placemarks] if options.has_key? :show_placemarks
-            hash[:roll] = val(options[:roll], i, p) if options.has_key? :roll
-            hash[:range] = val(options[:range], i, p) if options.has_key? :range
-            hash[:pause] = val(options[:pause], i, p) if options.has_key? :pause
+            #hash[:roll] = val(options[:roll], i, p) if options.has_key? :roll
+            #hash[:range] = val(options[:range], i, p) if options.has_key? :range
+            #hash[:pause] = val(options[:pause], i, p) if options.has_key? :pause
 
-            if hash.has_key? :duration
+            if options.has_key? :duration
                 duration = val(options[:duration], i, p)
             else
                 duration = (i == 0 ? 0 : 2)
             end
+            hash[:duration] = duration
+
+            if options.has_key? :multidim then
+                options[:multidim].each do |md|
+                    r = val(md[0], i, p)
+                    md[1].each_index do |ind|
+                        hash[md[1][ind]] = r[0, ind] unless md[1][ind].nil?
+                    end
+                end
+            end
 
             hash[:callback_value] = callback_value unless callback_value.nil?
-            tmp = yield(i, hash)
-            hash = tmp unless tmp.nil?
+
+            begin
+                tmp = yield(i, hash)
+                hash = tmp unless tmp.nil?
+            rescue LocalJumpError
+                # Don't do anything; there's no block to yield to
+            end
             #hash = options[:callback].call(i, hash) if options.has_key? :callback
             callback_value = hash[:callback_value] if hash.has_key? :callback_value
 
             v = make_view_from(hash)
             p = point(v.longitude, v.latitude, v.altitude, hash[:altitudeMode], hash[:extrude])
-            get_folder << placemark(i.to_s, :geometry => p) if hash.has_key? :show_placemarks
+            # XXX Should I add the view's timestamp / timespan, if it exists, to the placemark?
+            pl = placemark(i.to_s, :geometry => p)
+            pl.abstractView = v
+            get_folder << pl if hash.has_key? :show_placemarks
             fly_to v, :duration => duration , :mode => :smooth unless hash.has_key? :no_flyto
-            result_points << v
+            views << v
+            placemarks << pl
 
             pause hash[:pause] if hash.has_key? :pause
 
             i = i + 1
         end
-        result_points
+        [views, placemarks]
     end
 
 end
+
+## Example
+#make_function_path(10,
+#    :latitude => Line.interpolate(38.8, 40.3),
+#    :altitude => Line.interpolate(10000, 2000),
+#    :heading => Line.interpolate(0, 90),
+#    :tilt => Line.interpolate(40.0, 90),
+#    :roll => 0,
+#    :show_placemarks => 1,
+#    :duration => Quadratic.interpolate(2.0, 4.0, 0.0, 1.0),
+#) do |a, v|
+#    puts "callback here"
+#    if v.has_key? :callback_value then
+#        v[:callback_value] += 1
+#    else
+#        v[:pause] = 0.01
+#        v[:callback_value] = 1
+#    end
+#    puts v[:callback_value]
+#    v
+#end

data/lib/kamelopard/helpers.rb

@@ -401,15 +401,21 @@
   
   # Given a hash of values, this creates an AbstractView object. Possible
   # values in the hash are :latitude, :longitude, :altitude, :altitudeMode,
-  # :tilt, :heading, :roll, and :range. If the hash specifies :roll, a Camera
-  # object will result; otherwise, a LookAt object will result. Specifying both
-  # :roll and :range will still result in a Camera object, and the :range
-  # option will be ignored. :roll and :range have no default; all other values
-  # default to 0 except :altitudeMode, which defaults to :relativeToGround
+  # :tilt, :heading, :roll, :range, :begin, :end, and :when. If the hash
+  # specifies :roll, a Camera object will result; otherwise, a LookAt object
+  # will result. Specifying both :roll and :range will still result in a Camera
+  # object, and the :range option will be ignored.
+  #
+  # :begin, :end, and :when are used to create the view's timestamp or timespan
+  #
+  # :roll, :range, and the timestamp / timespan options have no default; all
+  # other values default to 0 except :altitudeMode, which defaults to
+  # :relativeToGround. 
   def make_view_from(options = {})
       o = {}
       o.merge! options
-      options.each do |k, v| o[k.to_sym] = v unless k.kind_of? Symbol
+      options.each do |k, v|
+          o[k.to_sym] = v unless k.kind_of? Symbol
       end
   
       # Set defaults
@@ -432,8 +438,18 @@
       else
           view = Kamelopard::LookAt.new p
       end
+
+      if o.has_key? :when then
+          o[:timestamp] = Kamelopard::TimeStamp.new(o[:when])
+      elsif o.has_key? :begin or o.has_key? :end then
+          (b, e) = [nil, nil]
+          b = o[:begin] if o.has_key? :begin
+          e = o[:end] if o.has_key? :end
+          o[:timespan] = Kamelopard::TimeSpan.new(b, e)
+      end
   
-      [ :altitudeMode, :tilt, :heading, :timestamp, :timespan, :timestamp, :range, :roll, :viewerOptions ].each do |a|
+      [ :altitudeMode, :tilt, :heading, :timespan, :timestamp, :range, :roll, :viewerOptions ].each do |a|
+          #p o[a] if o.has_key? a and a == :timestamp
           view.method("#{a.to_s}=").call(o[a]) if o.has_key? a
       end
   
@@ -596,3 +612,49 @@
   def get_doc_holder
     return Kamelopard::DocumentHolder.instance
   end
+
+    # Generates a series of points in a path that will simulate Earth's FlyTo in
+    # bounce mode, from one view to another. Note that the view objects must be
+    # the same time: either LookAt, or Camera
+    #--
+    # XXX Fix the limitation that the views must be the same type
+    # XXX Make the height of the bounce relate to the distance of the travel
+    # XXX Make the direction of change for elements that cycle smart enough to
+    #     choose the shortest direction around the circle
+    #++
+    def bounce(a, b, duration, points, options = {})
+        raise "Arguments to bounce() must either be Camera or LookAt objects, and must be the same type" unless
+            ((a.kind_of? Kamelopard::Camera and b.kind_of? Kamelopard::Camera) or
+             (a.kind_of? Kamelopard::LookAt and b.kind_of? Kamelopard::LookAt))
+        # The idea here is just to generate a function; the hard bit is finding
+        # control points.
+        include Kamelopard
+        include Kamelopard::Functions
+
+        max_alt = a.altitude
+        max_alt = b.altitude if b.altitude > max_alt
+
+        opts = {
+            :latitude => Line.interpolate(a.latitude, b.latitude),
+            :longitude => Line.interpolate(a.longitude, b.longitude),
+            :heading => Line.interpolate(a.heading, b.heading),
+            :tilt => Line.interpolate(a.tilt, b.tilt),
+                # XXX This doesn't really work. An actual altitude requires a
+                # value, and a mode, and we ignore the modes because there's no
+                # way for us to figure out absolute altitudes given, say,
+                # :relativeToGround
+            :altitude => Quadratic.interpolate(a.altitude, b.altitude, 0.3 / 1.6, 1.3 * (b.altitude - a.altitude).abs),
+#            def self.interpolate(ymin, ymax, x1, y1, min = -1.0, max = 1.0)
+            :altitudeMode => a.altitudeMode,
+            :duration => duration * 1.0 / points,
+        }
+        opts[:no_flyto] = 1 if options.has_key?(:no_flyto)
+        opts[:show_placemarks] = 1 if options.has_key?(:show_placemarks)
+
+        if a.kind_of? Camera then
+            opts[:roll] = Line.interpolate(a.roll, b.roll)
+        else
+            opts[:range] = Line.interpolate(a.range, b.range)
+        end
+        return make_function_path(points, opts)
+    end

data/lib/kamelopard/multicam.rb

@@ -0,0 +1,181 @@
+require 'matrix'
+
+module Kamelopard
+    module Multicam
+        def self.cross_product(v1, v2)
+            x =   ( (v1[1] * v2[2]) - (v1[2] * v2[1]) )
+            y = - ( (v1[0] * v2[2]) - (v1[2] * v2[0]) )
+            z =   ( (v1[0] * v2[1]) - (v1[1] * v2[0]) )
+            return Vector[x, y, z]
+        end
+
+        def self.dotprod_angle(a, b, negate = false)
+            begin
+                d = 180.0 * (Math.acos(a.inner_product(b) / a.r / b.r)) / Math::PI
+            rescue
+                d = 0
+                #puts "argument was #{a.inner_product(b)}, from vectors #{a} and #{b}"
+            end
+            d = 0 if d.respond_to? :nan? and d.nan?
+            raise "#{a}, #{b}, #{a.inner_product(b)}" if d == Float::INFINITY
+
+            # Complicating factor: dot product goes from 0 to 180, not 0 to 360. We'll
+            # have to know whether to negate based on external input (like if the
+            # original angle involved was close to the threshold)
+            d = -d if negate
+
+            return d
+        end
+
+        def self.rot_x(a)
+            # This, and the other two rotation matrix functions, must convert
+            # the angle to radians
+            a = a * Math::PI / 180.0
+            return Matrix[[1, 0, 0], [0, Math.cos(a), -1 * Math.sin(a)], [0, Math.sin(a), Math.cos(a)]]
+        end
+
+        def self.rot_y(a)
+            a = a * Math::PI / 180.0
+            return Matrix[[Math.cos(a), 0, Math.sin(a)], [0, 1, 0], [-1 * Math.sin(a), 0, Math.cos(a)]]
+        end
+
+        def self.rot_z(a)
+            a = a * Math::PI / 180.0
+            return Matrix[[Math.cos(a), -1 * Math.sin(a), 0], [Math.sin(a), Math.cos(a), 0], [0, 0, 1]]
+        end
+
+        def self.same_quadrant(a, b)
+            (0..2).each do |i|
+                return false if (a[i] > 0 and b[i] < 0) or (a[i] < 0 and b[i] > 0)
+            end
+            return true
+        end
+
+        # Vec is the camera vector. up_vec is the vector out the top of the camera
+        def self.vector_to_camera(vec, up_vec)
+            # The heading is the angle between two planes, the first formed by the
+            # camera vector and the original Z axis, and the second formed by the
+            # original Y and Z axes. This angle between two planes is the same
+            # as the angle between their two normals. The normal of the first
+            # plane is the cross product of the two vector, and that of the
+            # second is simply the X axis. The first cross product will be zero
+            # if the camera position vector is parallel to the Z axis; in that
+            # case we want the angle between the up vector and the y axis
+            # This will only find values up to 180 degrees, and won't
+            # distinguish direction correctly. For that, look at the Z
+            # component of the cross product of the two normals.
+            cam_z_norm = cross_product(vec, Vector[0,0,-1])
+            if cam_z_norm.r == 0
+                heading = dotprod_angle(up_vec, Vector[0,1,0],
+                    (cross_product(up_vec, Vector[0,1,0])[2] > 0))
+            else
+                heading = dotprod_angle(cam_z_norm, Vector[1,0,0],
+                    (cross_product(cam_z_norm, Vector[1,0,0])[2] > 0))
+            end
+
+            # Tilt is calculated from the vector alone, and is the angle between it and
+            # the original Z axis, calculated via the dot product
+            tilt = dotprod_angle(vec, Vector[0,0,1])
+
+            # For roll, take the original UP vector, and now that I've got
+            # valid heading and tilt, transform it by those values. Take the
+            # angle between it and my current UP vector. Make it negative if
+            # their cross product, up vector first, isn't the same direction as
+            # the camera vector.
+            transformed_up = rot_z(heading) * rot_x(tilt) * Vector[0,1,0]
+            if cross_product(up_vec, transformed_up).r == 0
+                negate = not(same_quadrant(up_vec, transformed_up))
+            else
+                negate = same_quadrant(vec, cross_product(up_vec, transformed_up))
+            end
+            roll = dotprod_angle(up_vec, transformed_up, negate)
+
+            return [heading, tilt, roll]
+        end
+
+        def self.make_placemark(name, lat, lon, alt, tilt, roll, heading)
+            p = point(lon, lat, alt, :relativeToGround)
+            l = camera p, :heading => heading, :tilt => tilt, :roll => roll, :altitudeMode => :relativeToGround
+            pl = placemark(name, :geometry => p, :abstractView => l)
+            f = get_folder
+            f << pl
+        end
+
+        # XXX Change / augment API, so that this function, or a cognate, takes
+        # a view, and returns a view modified for the camera in question
+        def self.get_camera(heading, tilt, roll, cam_num, cam_angle, cam_count = nil)
+            if cam_angle.nil? then
+                cam_angle = cam_num * 360.0 / cam_count
+            else
+                cam_angle = cam_angle * cam_num
+            end
+            # The camera vector is [0,0,1] rotated around the Y axis the amount
+            # of the camera angle
+            camera = rot_y(cam_angle) * Vector[0,0,1]
+
+            # The up vector is the same for all cameras
+            up = Vector[0,1,0]
+            matrix = rot_z(heading) * rot_x(tilt) * rot_z(roll)
+            (h, t, r) = vector_to_camera(matrix * camera, matrix * up)
+            # XXX What am I getting wrong, to require the negated roll?
+            return [h, t, -1 * r]
+        end
+
+        def self.test(kml_name = 'multicam_test.kml')
+            name_document 'tourvid'
+            get_document().open = 1
+
+            [:roll, :tilt, :heading].each do |which|
+                camera = Vector[0,0,1]
+                heading = 0
+                tilt = 45
+                roll = 0
+                lat = 40
+                lon = -111
+                alt = 100
+
+                puts "------------------"
+                puts "Running #{which}"
+                folder which.to_s
+                get_folder().open = 1
+
+                up = Vector[0,1,0]
+                (0..36).each do |i|
+                    if which == :roll then
+                        roll = -180 + i * 10
+                        heading = 23
+                    elsif which == :heading then
+                        heading = i * 10
+                        heading = heading - 360 if heading >= 180
+                    else
+                        tilt = i * 5
+                    end
+
+                    # This has been verified visually as the right matrix
+                    matrix = rot_z(heading) * rot_x(tilt) * rot_z(roll)
+
+                    trans_up = matrix * up
+                    trans_cam = matrix * camera
+                    trans_cross = cross_product(trans_cam, trans_up)
+                    (screen_head, screen_tilt, screen_roll) = vector_to_camera(trans_cam, trans_up)
+
+                    diff_limit = 3
+                    a = dotprod_angle(trans_up, trans_cam)
+                    if ((heading - screen_head).abs > diff_limit or (tilt - screen_tilt).abs > diff_limit or (roll - screen_roll).abs > diff_limit) then
+                    #if which == :roll then
+                        puts "  PLACEMARK #{i}"
+#                        puts "    Camera vector: #{trans_cam}, mag: #{trans_cam.r}"
+#                        puts "    Up vector: #{trans_up}, mag: #{trans_up.r}"
+#                        puts "    Cross prod: #{trans_cross}, mag: #{trans_cross.r}"
+                        puts "    UpZ: #{trans_up[2]}"
+                        puts "    Orig H/T/R: #{heading}/#{tilt}/#{roll}"
+                        puts "    Screen H/T/R: #{screen_head}/#{screen_tilt}/#{screen_roll}"
+                    end
+                    make_placemark(i, lat, lon, alt, screen_tilt, screen_roll, screen_head)
+                end
+                puts
+                write_kml_to kml_name
+            end
+        end
+    end
+end

data/lib/kamelopard/spline.rb

@@ -2,56 +2,88 @@
 require 'matrix'
 
 # Basic support for splines
-
 module Kamelopard
-    def spline(lists = [], resolution = [10])
-        # Ruby implementation of Catmull-Rom splines (http://www.cubic.org/docs/hermite.htm)
-
-        size = lists.collect { |l| l.size }.max
-        STDERR.puts size
-
-        h = Matrix[
-            [ 2,  -2,   1,   1 ],
-            [-3,   3,  -2,  -1 ],
-            [ 0,   0,   1,   0 ],
-            [ 1,   0,   0,   0 ],
-        ]
-
-        # XXX This needs to be fixed
-        result = []
-
-        idx = 0
-        resolution = [resolution] if ! resolution.respond_to? :[]
-
-        # Calculate spline between every two points
-        (0..(size-2)).each do |i|
-            p1 = lists_at(lists, i)
-            p2 = lists_at(lists, i+1)
-            
-            # Get surrounding points for calculating tangents
-            if i <= 0 then pt1 = p1 else pt1 = lists_at(lists, i-1) end
-            if i >= size - 2 then pt2 = p2 else pt2 = lists_at(lists, i+2) end
-
-            # Build tangent points into matrices to calculate tangents.
-            t1 = 0.5 * ( Matrix[p2]  - Matrix[pt1] )
-            t2 = 0.5 * ( Matrix[pt2] - Matrix[p1] )
-
-            # Build matrix of Hermite parameters
-            c = Matrix[p1, p2, t1.row(0), t2.row(0)]
-
-            # Make a set of points
-            point_count = (resolution[idx] * 1.0 / size).to_i
-            STDERR.puts point_count
-            (0..point_count).each do |t|
-                r = t/10.0
-                s = Matrix[[r**3, r**2, r, 1]]
-                tmp = s * h
-                p = tmp * c
-                result << p.row(0).to_a
+    module Functions
+        class SplineFunction < FunctionMultiDim
+            attr_reader :control_points, :total_dur, :tension
+
+            def initialize(ndims, tension = 0.5)
+                @ndims = ndims
+                @control_points = []
+                @total_dur = 0
+                @tension = tension
+                super()
+            end
+
+            # Adds a new control point. :dur is a way of indicating the
+            # duration of the journey from the last point to this one, and is
+            # ignored for the first control point in the spline. Values for
+            # :dur are in whatever units the user wants; a spline with three
+            # control points with durations of 0, 10, and 20 will be identical
+            # to one with durations of 0, 1, and 2.
+            def add_control_point(point, dur)
+                @total_dur = @total_dur + dur if @control_points.size > 0
+                @control_points << [ point, dur ]
+            end
+
+            def run_function(x)
+                # X will be between 0 and 1
+                # Find which control points I should am using for the point in
+                # question
+
+                dur = 0
+                last_dur = 0
+                cur_i = 0
+                u = 0
+                @control_points.each_index do |i|
+                    next if i == 0
+                    cur_i = i
+                    last_dur = dur
+                    if 1.0 * (dur + @control_points[i][1]) / @total_dur >= x then
+                        # I've found the correct two control points: cp[i-1] and cp[i]
+                        # u is the point on the interval between the two control points
+                        # that we're interested in. 0 would be the first control point,
+                        # and 1 the second
+                        u = (x * @total_dur - dur) / @control_points[i][1]
+                        break
+                    end
+                    dur = dur + @control_points[i][1]
+                end
+
+                # http://www.cs.cmu.edu/~462/projects/assn2/assn2/catmullRom.pdf
+
+                # cp = control points. cur_i will be at least 1
+                # I need two control points on either side of this part of the
+                # spline. If they don't exist, duplicate the endpoints of the
+                # control points.
+                cp1 = @control_points[cur_i-1][0]
+                cp2 = @control_points[cur_i][0]
+                if cur_i == 1 then
+                    cpt1 = cp1
+                else
+                    cpt1 = @control_points[cur_i-2][0]
+                end
+                if cur_i >= @control_points.size - 1 then
+                    cpt2 = cp2
+                else
+                    cpt2 = @control_points[cur_i+1][0]
+                end
+
+                # Can't just say Matrix[cp], because that adds an extra
+                # dimension to the matrix, somehow.
+                cps = Matrix[cpt1, cp1, cp2, cpt2]
+
+                t = @tension
+                h = Matrix[
+                    [ 0, 1, 0, 0 ],
+                    [ -t, 0, t, 0 ],
+                    [ 2*t, t-3, 3-2*t, -t ],
+                    [ -t, 2-t, t-2, t]
+                ]
+
+                p = Matrix[[1, u, u**2, u**3]] * h * cps
+                return p
             end
-            idx += 1
-            idx = 0 if idx >= resolution.size
-        end
-        result
-    end
-end
+        end   ## End of SplineFunction class
+    end   ## End of Function module
+end   ## End of Kamelopard module

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kamelopard
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.12
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-15 00:00:00.000000000 Z
+date: 2013-06-18 00:00:00.000000000 Z
 dependencies: []
 description: Various classes and functions used to ease development of KML files,
   in particular for development of Google Earth tours
@@ -21,6 +21,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/kamelopard/multicam.rb
 - lib/kamelopard/geocode.rb
 - lib/kamelopard/classes.rb
 - lib/kamelopard/helpers.rb