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

kamelopard 0.0.6 → 0.0.7

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

@@ -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