kamelopard 0.0.13 → 0.0.14

data/lib/kamelopard/classes.rb

@@ -8,6 +8,7 @@
 
 # Pretty much everything important is in this module
 module Kamelopard
+    require 'bundler/setup'
     require 'singleton'
     require 'xml'
     require 'yaml'
@@ -57,6 +58,26 @@ module Kamelopard
         @@logger.call(level, mod, msg) unless @@logger.nil? or @@log_level > LogLevels[level]
     end
 
+    def Kamelopard.xml_to_hash(node, fields)
+        result = {}
+        fields.each do |field|
+            begin
+                if field =~ /:/
+                    xmlfield = field
+                else
+                    xmlfield = "kml:#{field}"
+                end
+                my_f = node.find("//#{xmlfield}").first
+                if ! my_f.nil?
+                    result[field.to_sym] = my_f.first
+                end
+            rescue NoMethodError
+                log(:debug, 'xml-to-hash', "Error getting field #{field} (#{xmlfileld}) from node")
+            end
+        end
+        result
+    end
+
     def Kamelopard.get_next_id   # :nodoc:
         @@sequence += 1
         @@sequence
@@ -318,6 +339,13 @@ module Kamelopard
             @altitude = altitude unless altitude.nil?
         end
 
+        # Converts an XML::Node to a Kamelopard::Point
+        def self.parse(p)
+            a = Kamelopard.xml_to_hash(p, %w[altitudeMode extrude coordinates])
+            (lon, lat, alt) = a[:coordinates].to_s.split(/,\s+/).collect { |a| a.to_f }
+            return Point.new(lon, lat, alt, :altitudeMode => a[:altitudeMode].to_s.to_sym, :extrude => a[:extrude].to_s.to_i)
+        end
+
         def longitude=(long)
             @longitude = Kamelopard.convert_coord(long)
         end
@@ -327,10 +355,13 @@ module Kamelopard
         end
 
         def to_s
-            p @extrude
             "Point (#{@longitude}, #{@latitude}, #{@altitude}, mode = #{@altitudeMode}, #{ @extrude == 1 ? 'extruded' : 'not extruded' })"
         end
 
+        def extrude=(a)
+            @extrude = ((a and a != 0) ? 1 : 0)
+        end
+
         def to_kml(elem = nil, short = false)
             e = XML::Node.new 'Point'
             super(e)
@@ -341,7 +372,7 @@ module Kamelopard
 
             if not short then
                 c = XML::Node.new 'extrude'
-                c << ( @extrude ? 1 : 0 ).to_s
+                c << @extrude.to_s
                 e << c
 
                 Kamelopard.add_altitudeMode(@altitudeMode, e)
@@ -499,7 +530,8 @@ module Kamelopard
 
     # Abstract class corresponding to KML's AbstractView object
     class AbstractView < Object
-        attr_accessor :timestamp, :timespan, :viewerOptions, :heading, :tilt, :roll, :range, :altitudeMode
+        attr_accessor :timestamp, :timespan, :viewerOptions, :heading, :tilt,
+        :roll, :range, :altitudeMode
         attr_reader :className, :point
 
         def initialize(className, point, options = {})
@@ -622,13 +654,14 @@ module Kamelopard
     class Camera < AbstractView
         def initialize(point = nil, options = {})
             super('Camera', point, options)
+            @roll = 0 if @roll.nil?
         end
 
         def range
             raise "The range element is part of LookAt objects, not Camera objects"
         end
 
-        def range=
+        def range=(a)
             # The range element doesn't exist in Camera objects
         end
     end
@@ -637,6 +670,37 @@ module Kamelopard
     class LookAt < AbstractView
         def initialize(point = nil, options = {})
             super('LookAt', point, options)
+            @range = 0 if @range.nil?
+        end
+
+        def self.parse(la)
+            # TimePrimitive
+#<!-- inherited from AbstractView element -->
+#<TimePrimitive>...</TimePrimitive>  <!-- gx:TimeSpan or gx:TimeStamp -->
+            # ViewerOptions
+#<gx:ViewerOptions>
+#<option> name=" " type="boolean">     <!-- name="streetview", "historicalimagery", "sunlight", or "groundnavigation" -->
+#</option>
+#</gx:ViewerOptions>
+            fields = %w[
+                longitude latitude altitude heading
+                tilt range altitudeMode
+                gx:TimeStamp gx:TimeSpan gx:ViewerOptions
+            ]
+            b = Kamelopard.xml_to_hash(la, fields)
+            a = {}
+            b.each do |k, v|
+                if k == :altitudeMode
+                    a[k] = v.to_s.to_sym
+                else
+                    a[k] = v.to_s.to_f
+                end
+            end
+            return LookAt.new(
+                Point.new( a[:longitude], a[:latitude], a[:altitude], :altitudeMode => a[:altitudeMode]),
+                :heading => a[:heading],
+                :tilt => a[:tilt],
+                :range => a[:range])
         end
 
         def roll
@@ -791,8 +855,8 @@ module Kamelopard
         end
 
         def description=(a)
-            b = CGI.escapeHTML(a)
-            if b != a then
+            b = CGI.escapeHTML(a) if b.is_a? String
+            if (! a.is_a? XML::Node) and b != a then
                 @description = XML::Node.new_cdata a
             else
                 @description = a
@@ -908,9 +972,10 @@ module Kamelopard
         end
 
         def styles_to_kml(elem)
+            # XXX Remove this
             raise "done here" if elem.class == Array
             @styles.each do |a|
-                a.to_kml(elem) unless a.attached?
+                a.to_kml(elem) # unless a.attached?
             end
         end
     end
@@ -1003,7 +1068,7 @@ module Kamelopard
         # this function, and tours for non-LG targets, work normally.
         attr_accessor :master_mode
 
-        def initialize(options = {})
+        def initialize(name = '', options = {})
             @tours = []
             @folders = []
             @vsr_actions = []
@@ -1087,18 +1152,44 @@ module Kamelopard
 
         def get_kml_document
             k = XML::Document.new
+
+#            # XXX Should this be add_namespace instead?
+#            ns_arr = [
+#                ['', 'http://www.opengis.net/kml/2.2'],
+#                ['gx', 'http://www.google.com/kml/ext/2.2'],
+#                ['kml', 'http://www.opengis.net/kml/2.2'],
+#                ['atom', 'http://www.w3.org/2005/Atom'],
+#                ['test', 'http://test.com']
+#            ]
+#            ns_arr.each do |a|
+#                nm = 'xmlns'
+#                nm = a[0] if a[0] != ''
+#                k.context.register_namespace(nm, a[1])
+#            end
+
             # XXX fix this
             #k << XML::XMLDecl.default
             k.root = XML::Node.new('kml')
             r = k.root
-            if @uses_xal then
-                r.attributes['xmlns:xal'] = "urn:oasis:names:tc:ciq:xsdschema:xAL:2.0"
-            end
-    # XXX Should this be add_namespace instead?
-            r.attributes['xmlns'] = 'http://www.opengis.net/kml/2.2'
-            r.attributes['xmlns:gx'] = 'http://www.google.com/kml/ext/2.2'
-            r.attributes['xmlns:kml'] = 'http://www.opengis.net/kml/2.2'
-            r.attributes['xmlns:atom'] = 'http://www.w3.org/2005/Atom'
+#            # XXX Should this be add_namespace instead?
+#            r.attributes['xmlns'] = 'http://www.opengis.net/kml/2.2'
+#            r.attributes['xmlns:gx'] = 'http://www.google.com/kml/ext/2.2'
+#            r.attributes['xmlns:kml'] = 'http://www.opengis.net/kml/2.2'
+#            r.attributes['xmlns:atom'] = 'http://www.w3.org/2005/Atom'
+            ns_values = [
+                [nil, 'http://www.opengis.net/kml/2.2'],
+                ['gx', 'http://www.google.com/kml/ext/2.2'],
+                ['kml', 'http://www.opengis.net/kml/2.2'],
+                ['atom', 'http://www.w3.org/2005/Atom'],
+            ]
+            if @uses_xal
+                ns_values << ['xal', "urn:oasis:names:tc:ciq:xsdschema:xAL:2.0"]
+            end
+            ns_values.each do |ns|
+                n = XML::Namespace.new(r, ns[0], ns[1])
+                r.namespaces.namespace = n if ns[0].nil?
+            end
+
             r << self.to_kml
             k
         end
@@ -1152,6 +1243,15 @@ module Kamelopard
             @document_index = a
         end
 
+        def delete_current_doc
+            @documents.delete_at @document_index unless @document_index == -1
+            if @documents.size > 0
+                @document_index = @documents.size - 1
+            else
+                @document_index = -1
+            end
+        end
+
         def current_document
             # Automatically create a Document if we don't already have one
             if @documents.size <= 0
@@ -1196,6 +1296,7 @@ module Kamelopard
 
         def initialize(color = nil, options = {})
             super options
+            @set_colorMode = false
             @color = color unless color.nil?
         end
 
@@ -1205,6 +1306,7 @@ module Kamelopard
 
         def colorMode=(a)
             validate_colorMode a
+            @set_colorMode = true
             @colorMode = a
         end
 
@@ -1246,9 +1348,11 @@ module Kamelopard
             e = XML::Node.new 'color'
             e << @color
             k << e
-            e = XML::Node.new 'colorMode'
-            e << @colorMode
-            k << e
+            if @set_colorMode then
+                e = XML::Node.new 'colorMode'
+                e << @colorMode
+                k << e
+            end
             k
         end
     end
@@ -1655,7 +1759,7 @@ module Kamelopard
 
         def initialize(view = nil, options = {})
             @duration = 0
-            @mode = :bounce
+            @mode = Kamelopard::DocumentHolder.instance.current_document.flyto_mode
             super options
             self.view= view unless view.nil?
         end
@@ -1679,6 +1783,8 @@ module Kamelopard
         def to_kml(elem = nil)
             k = XML::Node.new 'gx:FlyTo'
             super k
+
+            #k.namespaces.namespace = XML::Namespaces.new(k, 'gx', 'http://www.google.com/kml/ext/2.2')
             Kamelopard.kml_array(k, [
                 [ @duration, 'gx:duration' ],
                 [ @mode, 'gx:flyToMode' ]
@@ -1777,6 +1883,8 @@ module Kamelopard
             @duration = duration
         end
 
+        # Accepts an XML node representing a gx:Wait KML object, and turns it
+        # into a Kamelopard::Wait object
         def self.parse(x)
             dur = nil
             id = x.attributes['id'] if x.attributes? 'id'

data/lib/kamelopard/function.rb

@@ -3,6 +3,7 @@
 #++
 # Describes functions that can be calculated to create flight paths
 
+require 'bundler/setup'
 require 'matrix'
 
 #--

data/lib/kamelopard/function_paths.rb

@@ -8,7 +8,8 @@
 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.
+    # tour, using make_view_from() among other things. It will yield to a code
+    # block, if one is provided, as described below.
     # Arguments:
     #   points: The number of points in the series
     #   hash: Values used to create the hash, which creates the point in the
@@ -20,18 +21,13 @@ module Kamelopard
     #       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 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.
     #     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
+    #       The amount of time to pause after flying to each point, or nil for no pause
     #     show_placemarks
-    #       If set, a placemark object will be created at this point
+    #       If set, a placemark object will be created at each point
     #     no_flyto
     #       If set, on flyto objects will be created
     #     multidim
@@ -75,13 +71,13 @@ module Kamelopard
 
         callback_value = nil
         i = 0
-        while (i <= points)
+        while (i < points)
             p = i.to_f / points.to_f
             hash = {}
             [ :latitude, :longitude, :altitude, :heading,
               :tilt, :altitudeMode, :extrude, :when,
               :roll, :range, :pause, :begin, :end, :show_placemarks,
-              :no_flyto, :pause
+              :no_flyto
             ].each do |k|
                 if options.has_key? k then
                     hash[k] = val(options[k], i, p)

data/lib/kamelopard/geocode.rb

@@ -1,6 +1,7 @@
 # vim:ts=4:sw=4:et:smartindent:nowrap
 
 require 'rubygems'
+require 'bundler/setup'
 require 'net/http'
 require 'uri'
 require 'cgi'

data/lib/kamelopard/helpers.rb

@@ -12,6 +12,13 @@
   def set_flyto_mode_to(mode)
       Kamelopard::DocumentHolder.instance.current_document.flyto_mode = mode
   end
+
+    # Clears out the document_holder
+    def clear_documents
+        dh = get_doc_holder
+        dh.delete_current_doc while dh.documents.size > 0
+    end
+
   
   # Shows or hides the popup balloon for Placemark and ScreenOverlay objects.
   # Arguments are the object; 0 or 1 to hide or show the balloon, respectively;
@@ -153,45 +160,88 @@
       l.range += dist
       Kamelopard::FlyTo.new(l, nil, dur, mode)
   end
+
+    # Translates a heading into something between 0 and 360
+    def convert_heading(heading)
+        if heading > 360 then
+            step = -360
+        else
+            step = 360
+        end
+        while heading < 0 or heading > 360 do
+            heading = heading + step
+        end
+        heading
+    end
   
-  # Creates a list of FlyTo elements to orbit and look at a given point (center),
-  # at a given range (in meters), starting and ending at given angles (in
-  # degrees) from the center, where 0 and 360 (and -360, and 720, and -980, etc.)
-  # are north. To orbit clockwise, make startHeading less than endHeading.
-  # 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 = 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
-  
-      # When I tried this all in one step, ruby told me 360 / 10 = 1805. I'm sure
-      # there's some reason why this is a feature and not a bug, but I'd rather
-      # not look it up right now.
-      num = (endHeading - startHeading).abs
-      den = ((endHeading - startHeading) / 360.0).to_i.abs * 5 + 5
-      step = num / den
-      step = 1 if step < 1
-      step = step * -1 if startHeading > endHeading
-  
-      lastval = startHeading
-      mode = :bounce
-      startHeading.step(endHeading, step) do |theta|
-          lastval = theta
-          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, :heading => endHeading, :tilt => tilt, :range => range, :altitudeMode => am), :duration => 2, :mode => :smooth
-      end
-  end
+    # Creates a list of FlyTo elements to orbit and look at a given point (center),
+    # at a given range (in meters), starting and ending at given angles (in
+    # degrees) from the center, where 0 and 360 (and -360, and 720, and -980, etc.)
+    # are north. To orbit multiple times, add or subtract 360 from the
+    # endHeading. 
+    # The tilt argument matches the KML LookAt tilt argument
+    # already_there, if true, means we've already flown to the initial point
+    # The options hash can contain:
+    #   :duration   The total duration of the orbit. Defaults to 0, which means it will take 2 seconds per step
+    #   :step       How much to change the heading for each flyto. Defaults to some strange value >= 5
+    #   :already_there
+    #               Default false. Indicates that we've already flown to the initial position
+    def orbit(center, range = 100, tilt = 90, startHeading = 0, endHeading = 360, options = {})
+        duration = options.has_key?(:duration) ? options[:duration] : 0
+        step = options.has_key?(:step) ? options[:step] : nil
+        already_there = options.has_key?(:already_there) ? options[:already_there] : false
+
+        am = center.altitudeMode
   
-  # Adds a SoundCue object.
-  def sound_cue(href, ds = nil)
-      Kamelopard::SoundCue.new href, ds
-  end
+        if not step.nil? then
+            if (endHeading - startHeading > 0 and step < 0) or (endHeading - startHeading < 0 and step > 0) then
+                raise "Given start = #{startHeading}, end = #{endHeading}, and step = #{step}, this will be an infinite loop"
+            end
+        end
+    
+        # We want at least 5 points (arbitrarily chosen value), plus at least 5 for
+        # each full revolution
+    
+        # When I tried this all in one step, ruby told me 360 / 10 = 1805. I'm sure
+        # there's some reason why this is a feature and not a bug, but I'd rather
+        # not look it up right now.
+        dur = 2
+        if step.nil? then
+          num = (endHeading - startHeading).abs
+          num_steps = ((endHeading - startHeading) / 360.0).to_i.abs * 5 + 5
+          step = num / num_steps
+          step = 1 if step < 1
+          step = step * -1 if startHeading > endHeading
+          if already_there
+             num_steps = num_steps - 1
+             startHeading = startHeading + step
+          end
+          if duration != 0
+            dur = duration.to_f / num_steps
+          end
+        else
+          dur = duration * 1.0 / ((endHeading - startHeading) * 1.0 / step) if duration != 0
+          startHeading = startHeading + step if already_there
+        end
+    
+        lastval = startHeading
+        mode = :bounce
+        mode = :smooth if already_there
+        startHeading.step(endHeading, step) do |theta|
+            lastval = theta
+            heading = convert_heading theta
+            fly_to Kamelopard::LookAt.new(center, :heading => heading, :tilt => tilt, :range => range, :altitudeMode => am), :duration => dur, :mode => mode
+            mode = :smooth
+        end
+        if lastval != endHeading then
+            fly_to Kamelopard::LookAt.new(center, :heading => convert_heading(endHeading), :tilt => tilt, :range => range, :altitudeMode => am), :duration => dur, :mode => :smooth
+        end
+    end
+    
+    # Adds a SoundCue object.
+    def sound_cue(href, ds = nil)
+        Kamelopard::SoundCue.new href, ds
+    end
   
   # XXX This implementation of orbit is trying to do things the hard way, but the code might be useful for other situations where the hard way is the only possible one
   # def orbit(center, range = 100, startHeading = 0, endHeading = 360)
@@ -505,6 +555,7 @@
   
   # Pulls the Placemarks from the KML document d and yields each in turn to the caller
   # d = an XML::Document containing KML
+  # XXX This currently expects Placemarks to contain LookAt or Camera objects. It should do something useful with placemarks based on Points, or other objects
   def each_placemark(d)
       d.find('//kml:Placemark').each do |p|
           all_values = {}
@@ -616,7 +667,9 @@
 
     # 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
+    # the same time: either LookAt, or Camera. Options include :no_flyto and
+    # :show_placemarks, and match make_function_path's meanings for those
+    # options
     #--
     # XXX Fix the limitation that the views must be the same type
     # XXX Make it slow down a bit toward the end of the run
@@ -672,16 +725,20 @@
     # 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
+          a * Math::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))
+        d = 2 * radius * 
+            Math.asin( Math.sqrt(
+                Math.sin((lat2-lat1)/2)**2 +
+                Math.cos(lat1) * Math.cos(lat2) *
+                Math.sin((long2 - long1)/2)**2
+            ))
        
         return d
     end

data/lib/kamelopard/multicam.rb

@@ -1,3 +1,4 @@
+require 'bundler/setup'
 require 'matrix'
 
 module Kamelopard
@@ -84,7 +85,7 @@ module Kamelopard
             # 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))
+                negate = ! (same_quadrant(up_vec, transformed_up))
             else
                 negate = same_quadrant(vec, cross_product(up_vec, transformed_up))
             end

data/lib/kamelopard/multicamify.rb

@@ -5,6 +5,7 @@
 
 #require 'rubygems'
 $LOAD_PATH << './lib'
+require 'bundler/setup'
 require 'kamelopard'
 require 'libxml'
 

data/lib/kamelopard/regionate.rb

@@ -0,0 +1,99 @@
+module Kamelopard
+module Regionate
+    #require 'ai4r'
+    require 'bundler/setup'
+    require 'hierclust'
+
+    class Hierclust::Point
+        attr_accessor :placemark
+        def <=>(a)
+            raise "Something called this!"
+        end
+
+        def distance_to(b)
+            if self.is_a? Hierclust::Point then
+                pt1 = point(self.x, self.y)
+            else
+                pt1 = self.placemark.geometry
+            end
+            if b.is_a? Hierclust::Point then
+                pt2 = point(b.x, b.y)
+            else
+                pt2 = b.placemark.geometry
+            end
+            great_circle_distance(pt1, pt2)
+        end
+    end
+
+    # Regionate a bunch of placemarks. Add placemarks representing the centers
+    # of the discovered clusters to a folder if one is provided.
+    # Options:
+    #   :folder => The folder to add placemarks for each region to. Defaults to
+    #               nil, in which case no placemarks will be added
+    #   :minlod => minLod value for each region, defaults to 12000
+    #   :maxlod => minLod value for each region, defaults to -1 #   :dist   => minimum distance in degrees of lat/long between cluster centers
+    #def self.regionate(placemarks, count, options = {})
+    def self.regionate(placemarks, dist, options = {})
+        #include Ai4r::Data
+        #include Ai4r::Clusterers
+
+        options[:minlod] = 12000 unless options.has_key? :minlod and not options[:minlod].nil?
+        options[:maxlod] = -1    unless options.has_key? :maxlod and not options[:maxlod].nil?
+        hierpoints = []
+
+        placemarks.each do |g|
+            h = Hierclust::Point.new(g.longitude.to_f, g.latitude.to_f)
+            h.placemark = g
+            hierpoints << h
+        end
+        clusterer = Hierclust::Clusterer.new(hierpoints, dist)
+
+        centers = []
+        pmarks = []
+        regions = []
+
+        clusterer.clusters.each do |c|
+            Kamelopard.log(:debug, 'regionate', "Here's a cluster: #{c.points}")
+
+            r = Kamelopard::Region.new(
+                 # Do something based on ... dist, perhaps, when radius is 0
+                :latlonaltbox => Kamelopard::LatLonBox.new(
+                    # n, s, e, w
+                    c.y + c.radius,
+                    c.y - c.radius,
+                    c.x + c.radius,
+                    c.x - c.radius,
+                    0
+                ),
+                :lod => Kamelopard::Lod.new(options[:minlod], options[:maxlod], 0, 0)
+            #    -                :lod => Kamelopard::Lod.new(-1, options[:minlod], 0, 0)
+            )
+            regions << r
+
+            # Find placemarks in this cluster, and add region
+            c.points.each do |pt|
+                Kamelopard.log(:debug, 'regionate', "Found placemark #{pt.placemark.name} in the cluster")
+                pt.placemark.region = r
+            end
+
+            pl = placemark "#{c.size}-element cluster at #{c.y}, #{c.x}", :geometry => point(c.x, c.y, 0)
+            c_r = Kamelopard::Region.new(
+                :latlonaltbox => Kamelopard::LatLonBox.new(
+                    # n, s, e, w
+                    c.y + c.radius,
+                    c.y - c.radius,
+                    c.x + c.radius,
+                    c.x - c.radius,
+                    0
+                ),
+                :lod => Kamelopard::Lod.new(-1, options[:minlod], 0, 0)
+            )
+            pl.region = c_r
+            options[:folder] << pl unless options[:folder].nil?
+            pmarks << pl
+        end
+
+        [ clusterer.clusters, centers, pmarks ]
+    end
+end
+end

data/lib/kamelopard/spline.rb

@@ -1,4 +1,5 @@
 # vim:ts=4:sw=4:et:smartindent:nowrap
+require 'bundler/setup'
 require 'matrix'
 
 # Basic support for splines
@@ -82,7 +83,7 @@ module Kamelopard
                 ]
 
                 p = Matrix[[1, u, u**2, u**3]] * h * cps
-                return p
+                return p.row(0)
             end
         end   ## End of SplineFunction class
     end   ## End of Function module

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kamelopard
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.14
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-18 00:00:00.000000000 Z
+date: 2013-12-12 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,6 +23,7 @@ extra_rdoc_files: []
 files:
 - lib/kamelopard/multicam.rb
 - lib/kamelopard/multicamify.rb
+- lib/kamelopard/regionate.rb
 - lib/kamelopard/geocode.rb
 - lib/kamelopard/classes.rb
 - lib/kamelopard/helpers.rb
@@ -50,7 +51,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Tools for building KML