kamelopard 0.0.10 → 0.0.11

data/lib/kamelopard.rb

@@ -1,3 +1,5 @@
 require 'kamelopard/classes'
-require 'kamelopard/functions'
+require 'kamelopard/helpers'
 require 'kamelopard/geocode'
+require 'kamelopard/function'
+require 'kamelopard/function_paths'

data/lib/kamelopard/classes.rb

@@ -1,13 +1,14 @@
 # encoding: utf-8
+#--
 # vim:ts=4:sw=4:et:smartindent:nowrap
-
+#++
 # Classes to manage various KML objects. See
 # http://code.google.com/apis/kml/documentation/kmlreference.html for a
 # description of KML
 
+# Pretty much everything important is in this module
 module Kamelopard
     require 'singleton'
-    require 'kamelopard/pointlist'
     require 'xml'
     require 'yaml'
     require 'erb'
@@ -16,6 +17,14 @@ module Kamelopard
     @@sequence = 0
     @@id_prefix = ''
     @@logger = nil
+
+    # Valid log levels:
+    # * :debug
+    # * :info
+    # * :notice
+    # * :warn
+    # * :error
+    # * :fatal
     LogLevels = {
         :debug => 0,
         :info => 1,
@@ -29,35 +38,37 @@ module Kamelopard
 
     # Sets a logging callback function. This function should expect three
     # arguments. The first will be a log level (:debug, :info, :notice, :warn,
-    # :error, or :fatal); the second will be a module, categorizing the log
-    # entries generally; and the third will be the message
+    # :error, or :fatal); the second will be a text string, categorizing the
+    # log entries generally; and the third will be the log message itself
     def Kamelopard.set_logger(l)
         @@logger = l
     end
 
+    # Sets the current logging level. Valid levels are defined in the LogLevels hash
     def Kamelopard.set_log_level(lev)
         raise "Unknown log level #{lev}" unless LogLevels.has_key? lev
         @@log_level = LogLevels[lev]
     end
 
+    # Logs a message, provided a log level, a text string, and the log message.
+    # See #Kamelopard.set_logger for details.
     def Kamelopard.log(level, mod, msg)
         raise "Unknown log level #{level} for error message #{msg}" unless LogLevels.has_key? level
         @@logger.call(level, mod, msg) unless @@logger.nil? or @@log_level > LogLevels[level]
     end
 
-    def Kamelopard.get_document
-        DocumentHolder.instance.current_document
-    end
-
-    def Kamelopard.get_next_id   # :nodoc
+    def Kamelopard.get_next_id   # :nodoc:
         @@sequence += 1
         @@sequence
     end
 
+    # Sets a prefix for all kml_id values generated from this time forth. Does
+    # not change previously generated kml_ids
     def Kamelopard.id_prefix=(a)
         @@id_prefix = a
     end
 
+    # Returns the current kml_id prefix value. See #Kamelopard.id_prefix=
     def Kamelopard.id_prefix
         @@id_prefix
     end
@@ -73,7 +84,7 @@ module Kamelopard
     #   * if the second element is a proc, call the proc, passing it the KML
     #     object, and let the Proc (presumably) add itself to the KML
     #++
-    def Kamelopard.kml_array(e, m) # :nodoc
+    def Kamelopard.kml_array(e, m) # :nodoc:
         m.map do |a|
             if ! a[0].nil? then
                 if a[1].kind_of? Proc then
@@ -94,7 +105,7 @@ module Kamelopard
     #--
     # Accepts XdX'X.X", XDXmX.XXs, XdXmX.XXs, or X.XXXX with either +/- or N/E/S/W
     #++
-    def Kamelopard.convert_coord(a)    # :nodoc
+    def Kamelopard.convert_coord(a)    # :nodoc:
         a = a.to_s.upcase.strip.gsub(/\s+/, '')
 
         mult = 1
@@ -136,7 +147,7 @@ module Kamelopard
     end
 
     # Helper function for altitudeMode / gx:altitudeMode elements
-    def Kamelopard.add_altitudeMode(mode, e)
+    def Kamelopard.add_altitudeMode(mode, e) # :nodoc:
         return if mode.nil?
         if mode == :clampToGround or mode == :relativeToGround or mode == :absolute then
             t = XML::Node.new 'altitudeMode'
@@ -182,6 +193,14 @@ module Kamelopard
             end
         end
 
+        def change(attributes, values)
+            change = XML::Node.new 'Change'
+            child = XML::Node.new self.class.name
+            child.attributes[:targetId] = @kml_id
+            change << child
+            return change
+        end
+
         # If this is a master-only object, this function gets called internally
         # in place of the object's original to_kml method
         def _alternate_to_kml(*a)
@@ -297,7 +316,8 @@ module Kamelopard
         end
 
         def to_s
-            "Point (#{@longitude}, #{@latitude}, #{@altitude}, mode = #{@altitudeMode}, #{ @extrude ? 'extruded' : 'not extruded' })"
+            p @extrude
+            "Point (#{@longitude}, #{@latitude}, #{@altitude}, mode = #{@altitudeMode}, #{ @extrude == 1 ? 'extruded' : 'not extruded' })"
         end
 
         def to_kml(elem = nil, short = false)
@@ -496,7 +516,7 @@ module Kamelopard
                 else
                     a = point
                 end
-                @point = Point.new a.longitude, a.latitude, a.altitude, :altitudeMode => a.altitudeMode
+                @point = Point.new a.longitude, a.latitude, a.altitude, :altitudeMode => a.altitudeMode, :extrude => a.extrude
             end
         end
 
@@ -568,6 +588,10 @@ module Kamelopard
             t
         end
 
+        def to_queries_txt(name = '', planet = 'earth')
+            return "#{planet}@#{name}@flytoview=" + self.to_kml.to_s.gsub(/^\s+/, '').gsub("\n", '')
+        end
+
         def [](a)
             return @viewerOptions[a]
         end
@@ -951,7 +975,7 @@ module Kamelopard
         end
     end
 
-    def get_stack_trace   # :nodoc
+    def get_stack_trace   # :nodoc:
         k = ''
         caller.each do |a| k << "#{a}\n" end
         k
@@ -1131,6 +1155,11 @@ module Kamelopard
             @document_index += 1
         end
 
+        def set_current(a)
+            raise "Must set current document to an existing Document object" unless a.kind_of? Document
+            @document_index = @documents.index(a)
+        end
+
         def [](a)
             return @documents[a]
         end
@@ -1601,7 +1630,7 @@ module Kamelopard
         attr_accessor :standalone
 
         def initialize(options = {})
-            DocumentHolder.instance.current_document.tour << self unless options[:standalone]
+            DocumentHolder.instance.current_document.tour << self unless options.has_key?(:standalone)
             super
         end
     end

data/lib/kamelopard/function.rb

@@ -0,0 +1,163 @@
+#--
+# vim:ts=4:sw=4:et:smartindent:nowrap
+#++
+# Describes functions that can be calculated to create flight paths
+
+require 'matrix'
+
+#--
+#++
+module Kamelopard
+    
+    # Classes to manage functions, which can be interpolated into flight paths
+    # and other things
+    module Functions
+
+        # Abstract class representing a one-dimensional function
+        class Function1D
+            # 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.
+            attr_reader :min, :max, :start, :end
+            
+            # Another function this one is composed with, or appended to the end of this one
+            attr_reader :compose, :append
+
+            attr_accessor :verbose
+
+            def initialize(min = 0, max = 1)
+                @min = min
+                @max = max
+                @verbose = false
+            end
+
+            def max=(m)
+                raise "Cannot have a nil domain maximum" if m.nil?
+                @max = m
+            end
+
+            def min=(m)
+                raise "Cannot have a nil domain minimum" if m.nil?
+                @min = m
+            end
+
+            def compose=(f)
+                raise "Can only compose another one-dimensional function" unless f.kind_of? Function1D or f.nil?
+                @compose = f
+            end
+
+            def get_value(x)
+                raise "Value #{x} must be between 0 and 1" if (x.to_f > 1 or x.to_f < 0)
+                val = x * (max - min) + min
+                if @compose.nil? then
+                    return run_function(val)
+                else
+                    return run_function(@compose.get_value(val))
+                end
+            end
+
+            #def append(f)
+            #    raise "Can only append another one-dimensional function" unless f.kind_of? Function1D 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
+            #    # part of a domain, and another for the next. The domain of the second
+            #    # function will begin with the end of the last function.
+            #    # Perhaps allow two methods. One just appends the two; the second
+            #    # smooths things somewhat by adding to the result of the second the
+            #    # value of the first at the end of its domain.
+            #    @append = f
+            #end
+
+            def run_function(x)
+                raise "Override this method before calling it, please"
+            end
+
+            def self.interpolate(a, b)
+                # Creates a new Function1D object between points A and B
+                raise "Override this method before calling it, please"
+            end
+        end
+
+        # Represents a cubic equation of the form c3 * x^3 + c2 * x^2 + c1 * x + c0
+        class Cubic < Function1D
+            attr_accessor :c0, :c1, :c2, :c3
+            def initialize(c3 = 1.0, c2 = 0.0, c1 = 0.0, c0 = 0.0, min = -1.0, max = 1.0)
+                @c3 = c3.to_f
+                @c2 = c2.to_f
+                @c1 = c1.to_f
+                @c0 = c0.to_f
+                super min, max
+            end
+
+            def run_function(x)
+                puts "#{self.class.name}: [#{@min}, #{@max}] (#{@c3}, #{@c2}, #{@c1}, #{@c0}): #{x} -> #{ @c3 * x * x * x + @c2 * x * x + @c1 * x + @c0 }" if @verbose
+                return @c3 * x ** 3 + @c2 * x ** 2 + @c1 * x + @c0
+            end
+
+            def self.interpolate(ymin, ymax, x1, y1, x2, y2, min = -1.0, max = 1.0)
+                xm = Matrix[[min ** 3, x1 ** 3, x2 ** 3, max ** 3], [min ** 2, x1 ** 2, x2 ** 2, max ** 2], [min, x1, x2, max], [1, 1, 1, 1]]
+                ym = Matrix[[ymin, y1, y2, ymax]]
+                m = ym * xm.inverse
+                c3 = m[0,0]
+                c2 = m[0,1]
+                c1 = m[0,2]
+                c0 = m[0,3]
+                return Cubic.new(c3, c2, c1, c0, min, max)
+            end
+        end
+
+        # Describes a quadratic equation
+        class Quadratic < Cubic
+            def initialize(c2 = 1.0, c1 = 0.0, c0 = 0.0, min = -1.0, max = 1.0)
+                super(0.0, c2, c1, c0, min, max)
+            end
+
+            def self.interpolate(ymin, ymax, x1, y1, min = -1.0, max = 1.0)
+                x1 = (max.to_f + min) / 2.0 if x1.nil?
+                y1 = (ymax.to_f + ymin) / 2.0 if y1.nil?
+                xm = Matrix[[min ** 2, x1 ** 2, max ** 2], [min, x1, max], [1, 1, 1]]
+                ym = Matrix[[ymin, y1, ymax]]
+                m = ym * xm.inverse
+                c2 = m[0,0]
+                c1 = m[0,1]
+                c0 = m[0,2]
+                return Quadratic.new(c2, c1, c0, min, max)
+            end
+        end
+
+        # Describes a line
+        class Line < Cubic
+            def initialize(c1 = 1.0, c0 = 0.0, min = 0.0, max = 1.0)
+                super(0.0, 0.0, c1, c0, min, max)
+            end
+
+            def self.interpolate(a, b)
+                return Line.new(b - a, a)
+            end
+        end
+
+        class Constant < Cubic
+            def initialize(c0 = 0.0, min = 0.0, max = 1.0)
+                super(0, 0, 0, c0, min, max)
+            end
+            
+            # Interpolation isn't terribly useful for constants; to avoid using
+            # some superclass's interpolation accidentally, we'll just
+            # interpolate to the average of the two values
+            def self.interpolate(a, b)
+                return Constant.new((b.to_f - a.to_f) / 0.0)
+            end
+        end
+    end
+end 
+# include Kamelopard::Functions
+# 
+# l = Line.new 1.0, 0.0
+# puts l.get_value(0.35)
+# 
+# s = Quadratic.new
+# puts s.get_value(0.4)
+# 
+# l.compose = s
+# puts l.get_value(0.35)

data/lib/kamelopard/function_paths.rb

@@ -0,0 +1,96 @@
+#--
+# vim:ts=4:sw=4:et:smartindent:nowrap
+#++
+# Logic to create flyto paths from mathematical functions.
+
+#--
+#++
+module Kamelopard
+
+    # This function creates a hash, then uses that hash to create a point in a
+    # tour, using make_view_from() among other things.
+    # Arguments:
+    #   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
+    #       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
+    #       calculating, starting with 0, and the current value of the hash
+    #       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
+    #       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.
+    #     callback_value
+    #       A placeholder the callback function can use. It can set it when
+    #       it's called one time, and see that value when called the next time.
+    #     pause
+    #       The amount of time to pause after flying to this point, or nil for no pause
+    #     show_placemarks
+    #       If set, a placemark object will be created at this point
+    #     no_flyto
+    #       If set, on flyto objects will be created
+
+    def make_function_path(points = 10, options = {})
+
+        def val(a, b, c) # :nodoc:
+            if a.kind_of? Function1D then
+                return a.get_value(c)
+            elsif a.kind_of? Proc then
+                return a.call(b, a)
+            else
+                return a
+            end
+        end
+
+        result_points = []
+
+        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[: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
+
+            if hash.has_key? :duration
+                duration = val(options[:duration], i, p)
+            else
+                duration = (i == 0 ? 0 : 2)
+            end
+
+            hash[:callback_value] = callback_value unless callback_value.nil?
+            tmp = yield(i, hash)
+            hash = tmp unless tmp.nil?
+            #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
+            fly_to v, :duration => duration , :mode => :smooth unless hash.has_key? :no_flyto
+            result_points << v
+
+            pause hash[:pause] if hash.has_key? :pause
+
+            i = i + 1
+        end
+        result_points
+    end
+
+end

data/lib/kamelopard/{functions.rb → helpers.rb}

@@ -1,4 +1,7 @@
+#--
 # vim:ts=4:sw=4:et:smartindent:nowrap
+#++
+# Various helper functions
 
   # Returns the current Document object
   def get_document()
@@ -122,6 +125,8 @@
   
   # Returns the current Folder object
   def get_folder()
+      f = Kamelopard::DocumentHolder.instance.current_document.folders.last
+      Kamelopard::Folder.new() if f.nil?
       Kamelopard::DocumentHolder.instance.current_document.folders.last
   end
   
@@ -415,11 +420,12 @@
           [ :longitude, 0 ],
           [ :tilt, 0 ],
           [ :heading, 0 ],
+          [ :extrude, 0 ],
       ].each do |a|
           o[a[0]] = a[1] unless o.has_key? a[0]
       end
   
-      p = point o[:longitude], o[:latitude], o[:altitude], o[:altitudeMode]
+      p = point o[:longitude], o[:latitude], o[:altitude], o[:altitudeMode], o[:extrude]
   
       if o.has_key? :roll then
           view = Kamelopard::Camera.new p

data/lib/kamelopard/{pointlist.rb → spline.rb}

@@ -1,51 +1,11 @@
 # vim:ts=4:sw=4:et:smartindent:nowrap
 require 'matrix'
-#require 'kamelopard_classes'
 
-# XXX Right now I'm changing this to handle one-dimensional lists of numbers,
-# that can be added together. We'll probably want a way to add points, or other
-# numeric sets, to a set of pointlists easily. So for instance we can have
-# lists for altitude, longitude, and latitude, and add a single point to them
-# in one easy command.
+# Basic support for splines
 
 module Kamelopard
-    class NumberList
-        # Contains a list of numbers
-
-        def initialize(init = [])
-            raise "Constructor argument needs to be an array" unless init.kind_of? Array
-            @points = init
-        end
-
-        def size
-            return @points.size
-        end
-
-        def <<(a)
-            @points << a
-        end
-
-        def last
-            @points.last
-        end
-
-        def [](i)
-            @points[i]
-        end
-
-        def each(&blk)
-            @points.each(&blk)
-        end
-    end
-
-    def Kamelopard.lists_at(lists, i)
-        # The modulus ensures lists will repeat if they're not the same size
-        lists.collect { |l| l[i % l.size] }
-    end
-
-    def Kamelopard.interpolate(lists = [], resolution = [10])
+    def spline(lists = [], resolution = [10])
         # Ruby implementation of Catmull-Rom splines (http://www.cubic.org/docs/hermite.htm)
-        # Return NDPointList interpolating a path along all points in this list
 
         size = lists.collect { |l| l.size }.max
         STDERR.puts size
@@ -95,12 +55,3 @@ module Kamelopard
         result
     end
 end
-
-#a = Kamelopard::NumberList.new [1, 2, 3]
-#b = Kamelopard::NumberList.new [5, 6, 10]
-#
-#i = 0
-#Kamelopard.interpolate([a, b], [100]).each do |f|
-#    i += 1
-#    puts "#{i}\t#{f.inspect}"
-#end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kamelopard
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.11
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-14 00:00:00.000000000 Z
+date: 2013-04-15 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
@@ -23,8 +23,10 @@ extra_rdoc_files: []
 files:
 - lib/kamelopard/geocode.rb
 - lib/kamelopard/classes.rb
-- lib/kamelopard/functions.rb
-- lib/kamelopard/pointlist.rb
+- lib/kamelopard/helpers.rb
+- lib/kamelopard/function_paths.rb
+- lib/kamelopard/function.rb
+- lib/kamelopard/spline.rb
 - lib/kamelopard.rb
 homepage: http://www.endpoint.com/services/liquid_galaxy
 licenses: []