RubyGems - kamelopard - Versions diffs - 0.0.6 → 0.0.7 - Mend

kamelopard 0.0.6 → 0.0.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

data/lib/kamelopard/classes.rb +84 -22
data/lib/kamelopard/functions.rb +161 -24
data/lib/kamelopard/pointlist.rb +51 -76
metadata +4 -4

data/lib/kamelopard/classes.rb CHANGED

@@ -1,16 +1,16 @@
+# 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
-# XXX gx:balloonVisibility isn't represented here. Fix that.
 module Kamelopard
     require 'singleton'
     require 'kamelopard/pointlist'
     require 'xml'
     require 'yaml'
+    require 'erb'
     @@sequence = 0
     @@id_prefix = ''
@@ -396,7 +396,7 @@ module Kamelopard
                 else
                     a = point
                 end
-                @point = Point.new a.longitude, a.latitude, a.altitude
+                @point = Point.new a.longitude, a.latitude, a.altitude, :altitudeMode => a.altitudeMode
             end
         end
@@ -707,7 +707,7 @@ module Kamelopard
         def styleUrl=(a)
             if a.is_a? String then
                 @styleUrl = a
-            elsif a.respond_to? 'id' then
+            elsif a.respond_to? :kml_id then
                 @styleUrl = "##{ a.kml_id }"
             else
                 @styleUrl = a.to_s
@@ -870,6 +870,53 @@ module Kamelopard
             @folders.last
         end
+        # Makes a screenoverlay with a balloon containing links to the tours in this document
+        # The erb argument contains ERB to populate the description. It can be left nil
+        # The options hash is passed to the ScreenOverlay constructor
+        def make_tour_index(erb = nil, options = {})
+            options[:name] ||= 'Tour index'
+            options[:screenXY] ||= Kamelopard::XY.new(0.0, 1.0, :fraction, :fraction)
+            options[:overlayXY] ||= Kamelopard::XY.new(0.0, 1.0, :fraction, :fraction)
+            s = Kamelopard::ScreenOverlay.new options
+            t = ERB.new( erb || %{
+                <html>
+                    <body>
+                        <ul><% @tours.each do |t| %>
+                            <li><a href="#<%= t.kml_id %>;flyto"><% if t.icon.nil? %><%= t.name %><% else %><img src="<%= t.icon %>" /><% end %></a></li>
+                        <% end %></ul>
+                    </body>
+                </html>
+            })
+            s.description = XML::Node.new_cdata t.result(binding)
+            s.balloonVisibility = 1
+            balloon_au = [0, 1].collect do |v|
+                au = Kamelopard::AnimatedUpdate.new [], :standalone => true
+                a = XML::Node.new 'Change'
+                b = XML::Node.new 'ScreenOverlay'
+                b.attributes['targetId'] = s.kml_id
+                c = XML::Node.new 'gx:balloonVisibility'
+                c << XML::Node.new_text(v.to_s)
+                b << c
+                a << b
+                au << a
+                au
+            end
+            # Handle hiding and displaying the index
+            @tours.each do |t|
+                q = Wait.new(0.1, :standalone => true)
+                t.playlist.unshift balloon_au[0]
+                t.playlist.unshift q
+                t.playlist << balloon_au[1]
+                t.playlist << q
+            end
+            s
+        end
         def get_kml_document
             k = XML::Document.new
             # XXX fix this
@@ -1304,7 +1351,7 @@ module Kamelopard
     # Corresponds to KML's Placemark objects. The geometry attribute requires a
     # descendant of Geometry
     class Placemark < Feature
-        attr_accessor :name, :geometry
+        attr_accessor :name, :geometry, :balloonVisibility
         def initialize(name = nil, options = {})
             super
@@ -1315,6 +1362,11 @@ module Kamelopard
             k = XML::Node.new 'Placemark'
             super k
             @geometry.to_kml(k) unless @geometry.nil?
+            if ! @balloonVisibility.nil? then
+                 x = XML::Node.new 'gx:balloonVisibility'
+                 x << ( @balloonVisibility ? 1 : 0 )
+                 k << x
+            end
             elem << k unless elem.nil?
             k
         end
@@ -1352,9 +1404,14 @@ module Kamelopard
     # Abstract class corresponding to KML's gx:TourPrimitive object. Tours are made up
     # of descendants of these.
+    # The :standalone option affects only initialization; there's no point in
+    # doing anything with it after initialization. It determines whether the
+    # TourPrimitive object is added to the current tour or not
     class TourPrimitive < Object
+        attr_accessor :standalone
         def initialize(options = {})
-            Document.instance.tour << self
+            Document.instance.tour << self unless options[:standalone]
             super
         end
     end
@@ -1526,18 +1583,19 @@ module Kamelopard
     # Corresponds to a KML gx:Tour object
     class Tour < Object
-        attr_accessor :name, :description, :last_abs_view
+        attr_accessor :name, :description, :last_abs_view, :playlist, :icon
         def initialize(name = nil, description = nil)
             super()
             @name = name
             @description = description
-            @items = []
+            @playlist = []
             Document.instance.tours << self
         end
         # Add another element to this Tour
         def <<(a)
-            @items << a
+            @playlist << a
             @last_abs_view = a.view if a.kind_of? FlyTo
         end
@@ -1549,7 +1607,7 @@ module Kamelopard
                 [ @description, 'description' ],
             ])
             p = XML::Node.new 'gx:Playlist'
-            @items.map do |a| a.to_kml p end
+            @playlist.map do |a| a.to_kml p end
             k << p
             elem << k unless elem.nil?
             k
@@ -1580,7 +1638,7 @@ module Kamelopard
     # Corresponds to KML's ScreenOverlay object
     class ScreenOverlay < Overlay
-        attr_accessor :overlayXY, :screenXY, :rotationXY, :size, :rotation
+        attr_accessor :overlayXY, :screenXY, :rotationXY, :size, :rotation, :balloonVisibility
         def to_kml(elem = nil)
             k = XML::Node.new 'ScreenOverlay'
@@ -1594,6 +1652,11 @@ module Kamelopard
                 d << @rotation.to_s
                 k << d
             end
+            if ! @balloonVisibility.nil? then
+                 x = XML::Node.new 'gx:balloonVisibility'
+                 x << ( @balloonVisibility ? 1 : 0 )
+                 k << x
+            end
             elem << k unless elem.nil?
             k
         end
@@ -1995,10 +2058,10 @@ module Kamelopard
             end
             x << loc
             Kamelopard.add_altitudeMode(@location.altitudeMode, x)
-            @link.to_kml x
-            @orientation.to_kml x
-            @scale.to_kml x
-            @resourceMap.to_kml x
+            @link.to_kml x unless @link.nil?
+            @orientation.to_kml x unless @orientation.nil?
+            @scale.to_kml x unless @scale.nil?
+            @resourceMap.to_kml x unless @resourceMap.nil?
             elem << x unless elem.nil?
             x
         end
@@ -2077,12 +2140,12 @@ module Kamelopard
         attr_accessor :refreshVisibility, :flyToView, :link
         def initialize(href = '', options = {})
-            @refreshMode = :onChange
-            @viewRefreshMode = :never
-            super options
-            @link = Link.new(href, refreshMode, viewRefreshMode)
-            @refreshVisibility = 0
-            @flyToView = 0
+            super(( options[:name] || ''), options)
+            @refreshMode ||= :onChange
+            @viewRefreshMode ||= :never
+            @link = Link.new(href, :refreshMode => @refreshMode, :viewRefreshMode => @viewRefreshMode)
+            @refreshVisibility ||= 0
+            @flyToView ||= 0
         end
         def refreshMode
@@ -2147,6 +2210,5 @@ module Kamelopard
             e
         end
     end
 end
 # End of Kamelopard module

data/lib/kamelopard/functions.rb CHANGED

@@ -4,31 +4,63 @@ def fly_to(p, d = 0, r = 100, m = nil)
     Kamelopard::FlyTo.new p, :range => r, :duration => d, :mode => m
 end
+def get_document()
+    Kamelopard::Document.instance
+end
 def set_flyto_mode_to(a)
     Kamelopard::Document.instance.flyto_mode = a
 end
-def mod_popup_for(p, v)
-    au = Kamelopard::AnimatedUpdate.new
+def toggle_balloon_for(p, v, options = {})
+    au = Kamelopard::AnimatedUpdate.new [], options
+    if ! p.kind_of? Kamelopard::Placemark and ! p.kind_of? Kamelopard::ScreenOverlay then
+        raise "Can't show balloons for things that aren't Placemarks or ScreenOverlays"
+    end
+    a = XML::Node.new 'Change'
+    # XXX This can probably be more robust, based on just the class's name
+    if p.kind_of? Kamelopard::Placemark then
+        b = XML::Node.new 'Placemark'
+    else
+        b = XML::Node.new 'ScreenOverlay'
+    end
+    b.attributes['targetId'] = p.kml_id
+    c = XML::Node.new 'gx:balloonVisibility'
+    c << XML::Node.new_text(v.to_s)
+    b << c
+    a << b
+    au << a
+end
+def hide_balloon_for(p, options = {})
+    toggle_balloon_for(p, 0, options)
+end
+def show_balloon_for(p, options = {})
+    toggle_balloon_for(p, 1, options)
+end
+def fade_balloon_for(p, v, options = {})
+    au = Kamelopard::AnimatedUpdate.new [], options
     if ! p.is_a? Kamelopard::Placemark then
-        raise "Can't show popups for things that aren't placemarks"
+        raise "Can't show balloons for things that aren't placemarks"
     end
     a = XML::Node.new 'Change'
     b = XML::Node.new 'Placemark'
     b.attributes['targetId'] = p.kml_id
-    c = XML::Node.new 'visibility'
+    c = XML::Node.new 'color'
     c << XML::Node.new_text(v.to_s)
     b << c
     a << b
     au << a
 end
-def hide_popup_for(p)
-    mod_popup_for(p, 0)
+def fade_out_balloon_for(p, options = {})
+    fade_balloon_for(p, '00ffffff', options)
 end
-def show_popup_for(p)
-    mod_popup_for(p, 1)
+def fade_in_balloon_for(p, options = {})
+    fade_balloon_for(p, 'ffffffff', options)
 end
 def point(lo, la, alt=0, mode=nil, extrude = false)
@@ -36,6 +68,10 @@ def point(lo, la, alt=0, mode=nil, extrude = false)
     Kamelopard::Point.new(lo, la, alt, :altitudeMode => m, :extrude => extrude)
 end
+def placemark(name = nil, options = {})
+    Kamelopard::Placemark.new name, options
+end
 # Returns the KML that makes up the current Kamelopard::Document, as a string.
 def get_kml
     Kamelopard::Document.instance.get_kml_document
@@ -49,11 +85,19 @@ def pause(p)
     Kamelopard::Wait.new p
 end
+def get_tour()
+    Kamelopard::Document.instance.tour
+end
 def name_tour(a)
     Kamelopard::Document.instance.tour.name = a
 end
-def new_folder(name)
+def get_folder()
+    Kamelopard::Document.instance.folders.last
+end
+def folder(name)
     Kamelopard::Folder.new(name)
 end
@@ -62,6 +106,11 @@ def name_folder(a)
     return Kamelopard::Document.instance.folder
 end
+def name_document(a)
+    Kamelopard::Document.instance.name = a
+    return Kamelopard::Document.instance
+end
 def zoom_out(dist = 1000, dur = 0, mode = nil)
     l = Kamelopard::Document.instance.tour.last_abs_view
     raise "No current position to zoom out from\n" if l.nil?
@@ -135,7 +184,8 @@ def set_prefix_to(a)
 end
 def write_kml_to(file = 'doc.kml')
-    File.open(file, 'w') do |f| f.write get_kml.to_s.gsub(/balloonVis/, 'gx:balloonVis') end
+    File.open(file, 'w') do |f| f.write get_kml.to_s end
+    #File.open(file, 'w') do |f| f.write get_kml.to_s.gsub(/balloonVis/, 'gx:balloonVis') end
 end
 def fade_overlay(ov, show, options = {})
@@ -150,20 +200,6 @@ def fade_overlay(ov, show, options = {})
     k
 end
-def mod_balloon_for(a, val)
-    c = a.change('gx:balloonVisibility', val).to_s
-    STDERR.puts c
-    Kamelopard::AnimatedUpdate.new c
-end
-def show_balloon_for(a)
-    Kamelopard::AnimatedUpdate.new %{<Change><Placemark targetId="#{a.kml_id}"><balloonVisibility>1</balloonVisibility></Placemark></Change>}
-end
-def hide_balloon_for(a)
-    Kamelopard::AnimatedUpdate.new %{<Change><Placemark targetId="#{a.kml_id}"><balloonVisibility>0</balloonVisibility></Placemark></Change>}
-end
 module TelemetryProcessor
     Pi = 3.1415926535
@@ -281,3 +317,104 @@ def tour_from_points(points, options = {})
         TelemetryProcessor::add_flyto points[i,3]
     end
 end
+def make_view_from(options = {})
+    o = {}
+    o.merge! options
+    options.each do |k, v|
+        o[k.to_sym] = v unless k.kind_of? Symbol
+    end
+    # Set defaults
+    [
+        [ :altitude, 0 ],
+        [ :altitudeMode, :relativeToGround ],
+        [ :latitude, 0 ],
+        [ :longitude, 0 ],
+        [ :tilt, 0 ],
+        [ :heading, 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]
+    if o.has_key? :roll then
+        view = Kamelopard::Camera.new p
+    else
+        view = Kamelopard::LookAt.new p
+    end
+    [ :altitudeMode, :tilt, :heading, :timestamp, :timespan, :timestamp, :range, :roll, :viewerOptions ].each do |a|
+        view.method("#{a.to_s}=").call(o[a]) if o.has_key? a
+    end
+    view
+end
+def screenoverlay(options = {})
+    Kamelopard::ScreenOverlay.new options
+end
+def xy(x = 0.5, y = 0.5, xt = :fraction, yt = :fraction)
+    Kamelopard::XY.new x, y, xt, yt
+end
+def iconstyle(href = nil, options = {})
+    Kamelopard::IconStyle.new href, options
+end
+def labelstyle(scale = 1, options = {})
+    Kamelopard::LabelStyle.new scale, options
+end
+def style(options = {})
+    Kamelopard::Style.new options
+end
+def look_at(point = nil, options = {})
+    Kamelopard::LookAt.new point, options
+end
+def camera(point = nil, options = {})
+    Kamelopard::Camera.new point, options
+end
+def fly_to(view = nil, options = {})
+    Kamelopard::FlyTo.new view, options
+end
+# k = an XML::Document containing KML
+# Pulls the Placemarks from the KML document and flys to each one in turn
+def each_placemark(d)
+    i = 0
+    d.find('//kml:Placemark').each do |p|
+        all_values = {}
+        # These fields are part of the abstractview
+        view_fields = %w{ latitude longitude heading range tilt roll altitude altitudeMode gx:altitudeMode }
+        # These are other field I'm interested in
+        other_fields = %w{ description name }
+        all_fields = view_fields.clone
+        all_fields.concat(other_fields.clone)
+        all_fields.each do |k|
+            if k == 'gx:altitudeMode' then
+                ix = k
+                next unless p.find_first('kml:altitudeMode').nil?
+            else
+                ix = "kml:#{k}"
+            end
+            r = k == "gx:altitudeMode" ? :altitudeMode : k.to_sym
+            tmp = p.find_first("descendant::#{ix}")
+            next if tmp.nil?
+            all_values[k == "gx:altitudeMode" ? :altitudeMode : k.to_sym ] = tmp.content
+        end
+        view_values = {}
+        view_fields.each do |v| view_values[v] = all_values[v].clone if all_values.has_key? v end
+        yield make_view_from(view_values), all_values
+    end
+end
+def make_tour_index(erb = nil, options = {})
+    get_document.make_tour_index(erb, options)
+end

data/lib/kamelopard/pointlist.rb CHANGED

@@ -2,72 +2,54 @@
 require 'matrix'
 #require 'kamelopard_classes'
-class NDPointList
-    # Contains a list of N-dimensional numeric arrays
-    attr_reader :dim
-    def initialize(num)
-        raise "Can't have an NDPointList with #{num} dimensions -- must be 1 or more" if num < 1
-        @dim = num
-        @points = []
-    end
+# 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.
+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 size
+            return @points.size
+        end
-    def <<(a)
-        # Append points to our list
-        if a.kind_of? Kamelopard::Point then
-            if self.dim == 3 then
-                @points << [a.longitude, a.latitude, a.altitude]
-            else
-                @points << [a.longitude, a.latitude]
-            end
-        elsif a.respond_to? 'dim' and @dim != a.dim then
-            raise "Argument's dimension #{a.dim} must agree with our dimension #{@dim} to append to an NDPointList"
-        else
+        def <<(a)
             @points << a
         end
-    end
-    def last
-        @points.last
-    end
-    def [](i)
-        @points[i]
-    end
-    def x
-        @points.collect do |a| a[0] end
-    end
+        def last
+            @points.last
+        end
-    def y
-        if @dim >= 2 then
-            @points.collect do |a| a[1] end
-        else
-            raise "NDPointList of size #{@dim} has no Y element"
+        def [](i)
+            @points[i]
         end
-    end
-    def z
-        if @dim >= 2 then
-            @points.collect do |a| a[2] end
-        else
-            raise "NDPointList of size #{@dim} has no Z element"
+        def each(&blk)
+            @points.each(&blk)
         end
     end
-    def each(&blk)
-        @points.each(&blk)
+    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 interpolate(resolution = [10])
+    def Kamelopard.interpolate(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
         h = Matrix[
             [ 2,  -2,   1,   1 ],
             [-3,   3,  -2,  -1 ],
@@ -75,19 +57,20 @@ class NDPointList
             [ 1,   0,   0,   0 ],
         ]
-        result = NDPointList.new(@dim)
+        # XXX This needs to be fixed
+        result = []
         idx = 0
-        resolution = [resolution] if ! resolution.respond_to? []
+        resolution = [resolution] if ! resolution.respond_to? :[]
         # Calculate spline between every two points
-        (0..(self.size-2)).each do |i|
-            p1 = self[i]
-            p2 = self[i+1]
+        (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 = self[i-1] end
-            if i == self.size - 2 then pt2 = p2 else pt2 = self[i+2] end
+            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] )
@@ -97,7 +80,8 @@ class NDPointList
             c = Matrix[p1, p2, t1.row(0), t2.row(0)]
             # Make a set of points
-            point_count = (resolution[idx] * 1.0 / self.size).to_i
+            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]]
@@ -112,20 +96,11 @@ class NDPointList
     end
 end
-class OneDPointList < NDPointList
-    def initialize
-        super 1
-    end
-end
-class TwoDPointList < NDPointList
-    def initialize
-        super 2
-    end
-end
-class ThreeDPointList < NDPointList
-    def initialize
-        super 3
-    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 CHANGED

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: kamelopard
 version: !ruby/object:Gem::Version
-  hash: 19
+  hash: 17
   prerelease:
   segments:
   - 0
   - 0
-  - 6
-  version: 0.0.6
+  - 7
+  version: 0.0.7
 platform: ruby
 authors:
 - Joshua Tolley
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
-date: 2012-05-04 00:00:00 Z
+date: 2012-07-12 00:00:00 Z
 dependencies: []
 description: Various classes and functions used to ease development of KML files, in particular for development of Google Earth tours