kamelopard 0.0.3

data/lib/kamelopard/functions.rb

@@ -0,0 +1,119 @@
+# vim:ts=4:sw=4:et:smartindent:nowrap
+def fly_to(p, d = 0, r = 100, m = nil)
+    m = Document.instance.flyto_mode if m.nil?
+    FlyTo.new(p, r, d, m)
+end
+
+def set_flyto_mode_to(a)
+    Document.instance.flyto_mode = a
+end
+
+def mod_popup_for(p, v)
+    a = AnimatedUpdate.new
+    if ! p.is_a? Placemark then
+        raise "Can't show popups for things that aren't placemarks"
+    end
+    a << "<Change><Placemark targetId=\"#{p.id}\"><visibility>#{v}</visibility></Placemark></Change>"
+    a
+end
+
+def hide_popup_for(p)
+    mod_popup_for(p, 0)
+end
+
+def show_popup_for(p)
+    mod_popup_for(p, 1)
+end
+
+def point(lo, la, alt=0, mode=nil, extrude = false)
+    KMLPoint.new(lo, la, alt, mode.nil? ? :clampToGround : mode, extrude)
+end
+
+# Returns the KML that makes up the current Document, as a string.
+def get_kml
+    Document.instance.to_kml
+end
+
+def pause(p)
+    Wait.new p
+end
+
+def name_tour(a)
+    Document.instance.tour.name = a
+end
+
+def new_folder(name)
+    Folder.new(name)
+end
+
+def name_folder(a)
+    Document.instance.folder.name = a
+end
+
+def zoom_out(dist = 1000, dur = 0, mode = nil)
+    l = Document.instance.tour.last_abs_view
+    raise "No current position to zoom out from\n" if l.nil?
+    l.range += dist
+    FlyTo.new(l, nil, dur, mode)
+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 = 0, startHeading = 0, endHeading = 360)
+    fly_to LookAt.new(center, startHeading, tilt, range), 2, nil
+
+    # 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
+    startHeading.step(endHeading, step) do |theta|
+        lastval = theta
+        fly_to LookAt.new(center, theta, tilt, range), 2, nil, 'smooth'
+    end
+    if lastval != endHeading then
+        fly_to LookAt.new(center, endHeading, tilt, range), 2, nil, 'smooth'
+    end
+end
+
+def sound_cue(href, ds = nil)
+    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)
+#     p = ThreeDPointList.new()
+# 
+#     # Figure out how far we're going, and d
+#     dist = endHeading - startHeading
+# 
+#     # We want at least 5 points (arbitrarily chosen value), plus at least 5 for each full revolution
+#     step = (endHeading - startHeading) / ((endHeading - startHeading) / 360.0).to_i * 5 + 5
+#     startHeading.step(endHeading, step) do |theta|
+#         p << KMLPoint.new(
+#             center.longitude + Math.cos(theta), 
+#             center.latitude + Math.sin(theta), 
+#             center.altitude, center.altitudeMode)
+#     end
+#     p << KMLPoint.new(
+#         center.longitude + Math.cos(endHeading), 
+#         center.latitude + Math.sin(endHeading), 
+#         center.altitude, center.altitudeMode)
+# 
+#     p.interpolate.each do |a|
+#         fly_to 
+#     end
+# end

data/lib/kamelopard/geocode.rb

@@ -0,0 +1,62 @@
+# vim:ts=4:sw=4:et:smartindent:nowrap
+
+require 'net/http'
+require 'uri'
+require 'cgi'
+require 'json'
+
+# Geocoder base class
+class Geocoder
+    def initialize
+        raise "Unimplemented -- some other class should extend Geocoder and replace this initialize method"
+    end
+
+    def lookup(address)
+        raise "Unimplemented -- some other class should extend Geocoder and replace this lookup method"
+    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
+# testing suggests it's actually unnecessary
+class YahooGeocoder < Geocoder
+    def initialize(key)
+        @api_key = key
+        @proto = 'http'
+        @host = 'where.yahooapis.com'
+        @path = '/geocode'
+        @params = { 'appid' => @api_key, 'flags' => 'J' }
+    end
+
+    # Returns an object built from the JSON result of the lookup, or an exception
+    def lookup(address)
+        # 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( { 'q' => address } )
+        end
+        q = p.map { |k,v| "#{ CGI.escape(k) }=#{ 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(resp)
+        d = JSON.parse(resp)
+        raise d['ErrorMessage'] if d['Error'].to_i != 0
+        d
+    end
+end
+
+# EXAMPLE
+# require 'rubygems'
+# require 'kamelopard'
+# g = YahooGeocoder.new('some-api-key')
+# puts g.lookup({ 'city' => 'Springfield', 'count' => '100' })

data/lib/kamelopard/pointlist.rb

@@ -0,0 +1,127 @@
+# vim:ts=4:sw=4:et:smartindent:nowrap
+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
+
+    def size
+        return @points.size
+    end
+
+    def <<(a)
+        # Append points to our list
+        if a.kind_of? KMLPoint 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
+            @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 y
+        if @dim >= 2 then
+            @points.collect do |a| a[1] end
+        else
+            raise "NDPointList of size #{@dim} has no Y element"
+        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"
+        end
+    end
+
+    def each(&blk)
+        @points.each(&blk)
+    end
+
+    def interpolate(resolution = nil)
+        # XXX Figure out how to implement the "resolution" argument
+        STDERR.puts "resolution argument to NDPointList.interpolate is ignored" if resolution.nil?
+        # Ruby implementation of Catmull-Rom splines (http://www.cubic.org/docs/hermite.htm)
+        # Return NDPointList interpolating a path along all points in this list
+
+        h = Matrix[
+            [ 2,  -2,   1,   1 ],
+            [-3,   3,  -2,  -1 ],
+            [ 0,   0,   1,   0 ],
+            [ 1,   0,   0,   0 ],
+        ]
+
+        result = NDPointList.new(@dim)
+
+        # Calculate spline between every two points
+        (0..(self.size-2)).each do |i|
+            p1 = self[i]
+            p2 = self[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
+
+            # Build tangent points into matrices to calculate tangents.
+            t1 = 0.5 * ( Matrix[p2]  - Matrix[pt1] )
+            t2 = 0.5 * ( Matrix[pt2] - Matrix[p1] )
+
+            # Build matrix of Hermite parameters
+            c = Matrix[p1, p2, t1.row(0), t2.row(0)]
+
+            # Make a set of points
+            (0..10).each do |t|
+                r = t/10.0
+                s = Matrix[[r**3, r**2, r, 1]]
+                tmp = s * h
+                p = tmp * c
+                result << p.row(0).to_a
+            end
+        end
+        result
+    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

data/lib/kamelopard.rb

@@ -0,0 +1,3 @@
+require 'kamelopard/classes'
+require 'kamelopard/functions'
+require 'kamelopard/geocode'

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: kamelopard
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease: 
+platform: ruby
+authors:
+- Joshua Tolley
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-08-24 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
+email: josh@endpoint.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/kamelopard/geocode.rb
+- lib/kamelopard/classes.rb
+- lib/kamelopard/functions.rb
+- lib/kamelopard/pointlist.rb
+- lib/kamelopard.rb
+homepage: http://www.endpoint.com/services/liquid_galaxy
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.9
+signing_key: 
+specification_version: 3
+summary: Tools for building KML
+test_files: []