kamelopard 0.0.12 → 0.0.13

data/lib/kamelopard/classes.rb

@@ -115,7 +115,6 @@ module Kamelopard
             # Scientific notation
             return a.to_f
         end
-        p a
 
         mult = 1
         if a =~ /^-/ then
@@ -180,6 +179,12 @@ module Kamelopard
         # Set it to true to ensure it shows up only in slave mode.
         attr_reader :master_only
 
+        # Abstract function, designed to take an XML node containing a KML
+        # object of this type, and parse it into a Kamelopard object
+        def self.parse(x)
+            raise "Cannot parse a #{self.class.name}"
+        end
+
         # This constructor looks for values in the options hash that match
         # class attributes, and sets those attributes to the values in the
         # hash. So a class with an attribute called :when can be set via the
@@ -1772,6 +1777,15 @@ module Kamelopard
             @duration = duration
         end
 
+        def self.parse(x)
+            dur = nil
+            id = x.attributes['id'] if x.attributes? 'id'
+            w.find('//gx:duration').each do |d|
+                dur = d.children[0].to_s.to_f
+                return Wait.new(dur, :id => id)
+            end
+        end
+
         def to_kml(elem = nil)
             k = XML::Node.new 'gx:Wait'
             super k

data/lib/kamelopard/function.rb

@@ -169,6 +169,53 @@ module Kamelopard
                 return Constant.new((b.to_f - a.to_f) / 0.0)
             end
         end
+
+        # Interpolates between two points, choosing the shortest great-circle
+        # distance between the points.
+        class LatLonInterp < FunctionMultiDim
+            # a and b are points. This function will yield three variables,
+            # twice, expecting the block to return a one-dimensional function
+            # interpolating between the first two variables it was sent. The
+            # third variable yielded is a symbol, either :latitude or
+            # :longitude, to indicate which set of coordinates is being
+            # processed.
+            attr_reader :latfunc, :lonfunc
+
+            def initialize(a, b)
+                super()
+                (lat1, lon1) = [a.latitude, a.longitude]
+                (lat2, lon2) = [b.latitude, b.longitude]
+
+#                if (lat2 - lat1).abs > 90 
+#                    if lat2 > 0
+#                        lat2 = lat2 - 180
+#                    else
+#                        lat2 = lat2 + 180
+#                    end
+#                end
+
+                @latfunc = yield lat1, lat2, :latitude
+
+                if (lon2 - lon1).abs > 180 
+                    if lon2 > 0
+                        lon2 = lon2 - 360
+                    else
+                        lon2 = lon2 + 360
+                    end
+                end
+
+                @lonfunc = yield lon1, lon2, :longitude
+            end
+
+            def run_function(x)
+                (lat, lon) = [@latfunc.run_function(x), @lonfunc.run_function(x)]
+                lat = lat - 180 if lat > 90
+                lat = lat + 180 if lat < -90
+                lon = lon - 360 if lon > 180
+                lon = lon + 360 if lon < -180
+                return [lat, lon]
+            end
+        end ## End of LatLonInterp
     end  ## End of Functions sub-module
 end  ## End of Kamelopard module
 

data/lib/kamelopard/function_paths.rb

@@ -35,7 +35,7 @@ module Kamelopard
     #     no_flyto
     #       If set, on flyto objects will be created
     #     multidim
-    #       An array of hashes. Each array element is an array, containing two
+    #       An array. Each array element is itself 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
@@ -44,7 +44,8 @@ module Kamelopard
     #       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]} ]
+    #          [ [ myFunc, [:latitude, :longitude, nil, :altitude] ],
+    #            [ anotherFunc, [:pause] ] ]
     #       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
@@ -103,7 +104,7 @@ module Kamelopard
                 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?
+                        hash[md[1][ind]] = r[ind] unless md[1][ind].nil?
                     end
                 end
             end

data/lib/kamelopard/geocode.rb

@@ -8,20 +8,64 @@ require 'json'
 
 # Geocoder base class
 class Geocoder
+    attr_accessor :host, :path, :params
     def initialize
-        raise "Unimplemented -- some other class should extend Geocoder and replace this initialize method"
+        @params = {}
     end
 
+    def parse_response(r)
+        raise "Unimplemented -- use a child of the Geocoder class"
+    end
+end
+
+# Some specific geocoding API classes follow.  Google's would seem most
+# obvious, but since it requires you to display results on a map, ... I didn't
+# want to have to evaluate other possible restrictions, or require that they be
+# imposed on Kamelopard users.
+
+class MapquestGeocoder < Geocoder
+    attr_reader :api_key, :response_format
+
+    def initialize(key, response_format = 'json')
+        super()
+        @proto = 'http'
+        @host = 'www.mapquestapi.com'
+        @path = '/geocoding/v1/address'
+        @api_key = key
+        @response_format = response_format
+        @params['key'] = @api_key
+    end
+
+    # Returns an object built from the JSON result of the lookup, or an exception
     def lookup(address)
-        raise "Unimplemented -- some other class should extend Geocoder and replace this lookup method"
+        # The argument can be a string, in which case PlaceFinder does the parsing
+        # The argument can also be a hash, with several possible keys. See the PlaceFinder documentation for details
+        # http://developer.yahoo.com/geo/placefinder/guide/requests.html
+        http = Net::HTTP.new(@host)
+        if address.kind_of? Hash then
+            p = @params.merge address
+        else
+            p = @params.merge( { 'location' => address } )
+        end
+        q = p.map { |k,v| "#{ k == 'key' ? k : CGI.escape(k) }=#{ k == 'key' ? v : CGI.escape(v) }" }.join('&')
+        u = URI::HTTP.build([nil, @host, nil, @path, q, nil])
+
+        resp = Net::HTTP.get u
+        parse_response resp
+    end
+
+    def parse_response(r)
+        d = JSON.parse(r)
+        raise d['info']['messages'].join(', ') if d['info']['statuscode'] != 0
+        d
     end
 end
 
 # Uses Yahoo's PlaceFinder geocoding service: http://developer.yahoo.com/geo/placefinder/guide/requests.html
-# Google's would seem most obvious, but since it requires you to display
-# results on a map, ... I didn't want to have to evaluate other possible
-# restrictions. The argument to the constructor is a PlaceFinder API key, but
+# The argument to the constructor is a PlaceFinder API key, but
 # testing suggests it's actually unnecessary
+# NB! This is deprecated, as Yahoo's API is no longer free, and I'm not about to pay them to keep this tested.
+# http://developer.yahoo.com/blogs/ydn/introducing-boss-geo-next-chapter-boss-53654.html
 class YahooGeocoder < Geocoder
     def initialize(key)
         @api_key = key

data/lib/kamelopard/helpers.rb

@@ -109,8 +109,8 @@
   end
   
   # Inserts a KML gx:Wait element
-  def pause(p)
-      Kamelopard::Wait.new p
+  def pause(p, options = {})
+      Kamelopard::Wait.new p, options
   end
   
   # Returns the current Tour object
@@ -161,8 +161,8 @@
   # Otherwise, it will orbit counter-clockwise. To orbit multiple times, add or
   # subtract 360 from the endHeading. The tilt argument matches the KML LookAt
   # tilt argument
-  def orbit(center, range = 100, tilt = 0, startHeading = 0, endHeading = 360)
-      fly_to Kamelopard::LookAt.new(center, startHeading, tilt, range), 2, nil
+  def orbit(center, range = 100, tilt = 90, startHeading = 0, endHeading = 360)
+      am = center.altitudeMode
   
       # We want at least 5 points (arbitrarily chosen value), plus at least 5 for
       # each full revolution
@@ -177,12 +177,14 @@
       step = step * -1 if startHeading > endHeading
   
       lastval = startHeading
+      mode = :bounce
       startHeading.step(endHeading, step) do |theta|
           lastval = theta
-          fly_to Kamelopard::LookAt.new(center, theta, tilt, range), 2, nil, 'smooth'
+          fly_to Kamelopard::LookAt.new(center, :heading => theta, :tilt => tilt, :range => range, :altitudeMode => am), :duration => 2, :mode => mode
+          mode = :smooth
       end
       if lastval != endHeading then
-          fly_to Kamelopard::LookAt.new(center, endHeading, tilt, range), 2, nil, 'smooth'
+          fly_to Kamelopard::LookAt.new(center, :heading => endHeading, :tilt => tilt, :range => range, :altitudeMode => am), :duration => 2, :mode => :smooth
       end
   end
   
@@ -502,9 +504,8 @@
   end
   
   # Pulls the Placemarks from the KML document d and yields each in turn to the caller
-  # k = an XML::Document containing KML
+  # d = an XML::Document containing KML
   def each_placemark(d)
-      i = 0
       d.find('//kml:Placemark').each do |p|
           all_values = {}
   
@@ -618,9 +619,7 @@
     # 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
+    # XXX Make it slow down a bit toward the end of the run
     #++
     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
@@ -634,17 +633,28 @@
         max_alt = a.altitude
         max_alt = b.altitude if b.altitude > max_alt
 
+        bounce_alt = 1.3 * (b.altitude - a.altitude).abs
+            # 150 is the result of trial-and-error
+        gc = 0.8 * great_circle_distance(a, b) * 150
+        bounce_alt = gc if gc > bounce_alt
+        #raise "wtf: #{a.inspect}, #{b.inspect}"
+
+        latlonfunc = LatLonInterp.new(a, b) do |x, y, z|
+            Line.interpolate(x, y)
+        end
+
         opts = {
             :latitude => Line.interpolate(a.latitude, b.latitude),
             :longitude => Line.interpolate(a.longitude, b.longitude),
+            :multidim => [[ latlonfunc, [ :latitude, :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)
+                                                # ymin,    ymax        x1         y1
+            :altitude => Quadratic.interpolate(a.altitude, b.altitude, 0.5, bounce_alt),
             :altitudeMode => a.altitudeMode,
             :duration => duration * 1.0 / points,
         }
@@ -658,3 +668,20 @@
         end
         return make_function_path(points, opts)
     end
+
+    # Returns the great circle distance between two points
+    def great_circle_distance(a, b)
+        # Stolen from http://rosettacode.org/wiki/Haversine_formula#Ruby
+        include Math
+
+        def deg2rad(a)
+          a * PI / 180
+        end
+
+        radius = 6371  # rough radius of the Earth, in kilometers
+        lat1, long1 = [Math::PI * a.latitude / 180.0, Math::PI * a.longitude / 180.0]
+        lat2, long2 = [Math::PI * b.latitude / 180.0, Math::PI * b.longitude / 180.0]
+        d = 2 * radius * asin(sqrt(sin((lat2-lat1)/2)**2 + cos(lat1) * cos(lat2) * sin((long2 - long1)/2)**2))
+       
+        return d
+    end

data/lib/kamelopard/multicam.rb

@@ -101,8 +101,6 @@ module Kamelopard
             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
@@ -121,6 +119,14 @@ module Kamelopard
             return [h, t, -1 * r]
         end
 
+        def self.get_camera_view(v, cam_num, cam_angle, cam_count = nil)
+            (h, t, r) = get_camera(v.heading, v.tilt, v.roll, cam_num, cam_angle, cam_count)
+            v.heading = h
+            v.tilt = t
+            v.roll = r
+            v
+        end
+
         def self.test(kml_name = 'multicam_test.kml')
             name_document 'tourvid'
             get_document().open = 1

data/lib/kamelopard/multicamify.rb

@@ -0,0 +1,51 @@
+#!env ruby
+
+# The idea here is to ingest one tour from one KML document, and make it
+# multicamera-ish
+
+#require 'rubygems'
+$LOAD_PATH << './lib'
+require 'kamelopard'
+require 'libxml'
+
+# command line options: a single kml file. Prints KML to stdout
+
+def process_wait(w)
+    Kamelopard::Wait.parse(w)
+end
+
+def process_flyto(f)
+    # The idea here is to check the flytomode. If it's "smooth", just fly to
+    # that point. If it's "bounce", use bounce() to simulate the flyto. Since
+    # bounce() requires a start and an end, we'll need to keep track of where
+    # we are, so if the next flyto is a bounce, we have a start point.
+    # XXX Question: What if the *first* flyto is a bounce? We won't have a
+    # start point. Throw an error?
+    # XXX Should we assume a default value for flyToMode, if we don't find one?
+    f.find('//gx:flyToMode').each do |m|
+        if m.children[0].to_s == 'smooth'
+        break
+    end
+end
+
+d = XML::Document.file(ARGV[0])
+tours = d.find('//gx:Tour')
+if tours.size > 1 then
+    STDERR.puts "Found multiple tours in this document. Processing only the first."
+    # XXX Fix this
+elsif tours.size == 0 then
+    STDERR.puts "Found no tours in the document. Error."
+    exit 1
+end
+
+tour = tours[0]
+
+tour.find('//gx:FlyTo|//gx:Wait').each do |n|
+    if n.name == 'Wait'
+        Kamelopard::Wait.parse(w)
+    elsif n.name == 'FlyTo'
+        process_flyto n
+    end
+end
+
+puts get_kml.to_s

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kamelopard
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.0.13
   prerelease: 
 platform: ruby
 authors:
@@ -22,6 +22,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/kamelopard/multicam.rb
+- lib/kamelopard/multicamify.rb
 - lib/kamelopard/geocode.rb
 - lib/kamelopard/classes.rb
 - lib/kamelopard/helpers.rb