ruby_kml 0.1.7

data/lib/kml/model.rb

@@ -0,0 +1,40 @@
+module KML
+  class Model < Geometry
+
+    def initialize(params={})
+      @lng, @lat, @alt = *params[:location]
+      @heading, @tilt, @roll = *params[:orientation] || [0, 0, 0]
+      @x, @y, @z = *params[:scale] || [1, 1, 1]
+      @link = params[:link]
+      @id = params[:id] if params[:id]
+    end
+
+    def id
+      @id || "model_#{@link.href}_#{@x}_#{@y}"
+    end
+
+    def render(xm = Builder::XmlMarkup.new(:indent => 2))
+      xm.Model :id => id do
+        xm.altitudeMode(altitude_mode) if altitude_mode_set?
+        xm.Location do
+          xm.longitude @lng
+          xm.latitude  @lat
+          xm.altitude  @alt
+        end
+        xm.Orientation do
+          xm.heading @heading
+          xm.tilt    @tilt
+          xm.roll    @roll
+        end
+        xm.Scale do
+          xm.x @x
+          xm.y @y
+          xm.z @z
+        end
+        @link.render(xm)
+        # ResourceMap needs to be implemented still
+      end
+    end
+
+  end
+end

data/lib/kml/multi_geometry.rb

@@ -0,0 +1,26 @@
+module KML
+  class MultiGeometry < Geometry
+    def render(xm=Builder::XmlMarkup.new(:indent => 2))
+      xm.MultiGeometry { features.each { |f| f.render(xm) } }
+    end
+
+    def self.parse(node)
+      self.new.parse(node)
+    end
+
+    def parse(node)
+      super(node) do |cld|
+        case cld.name
+        when 'Polygon'
+          self.features << KML::Polygon.parse(cld)
+        else
+          puts "MultiGeometry"
+          p cld
+          puts
+        end
+      end
+      self
+    end
+
+  end
+end

data/lib/kml/object.rb

@@ -0,0 +1,37 @@
+module KML #:nodoc:
+  # Base class for all KML objects
+  class Object
+    # The KML object ID
+    attr_accessor :id
+
+    # Initialize the object, optionally passing a Hash of attributes to set.
+    def initialize(attributes=nil)
+      if attributes
+        case attributes
+        when Hash
+          attributes.each do |name, value|
+            self.__send__("#{name}=".to_sym, value)
+          end
+        else
+          raise ArgumentError, "Attributes must be specified as a Hash"
+        end
+      end
+    end
+
+    def parse(node)
+      self.id = node['id']
+      node.element_children.each do |cld|
+        yield cld
+      end
+      self
+    end
+  end
+end
+
+require 'kml/feature'
+require 'kml/geometry'
+require 'kml/color_style'
+require 'kml/style_selector'
+require 'kml/link'
+require 'kml/icon'
+require 'kml/lat_lon_box'

data/lib/kml/overlay.rb

@@ -0,0 +1,21 @@
+module KML
+  # Overlay is the base type for image overlays drawn on the planet surface or on the screen. +icon+ specifies the 
+  # image to use and can be configured to reload images based on a timer or by camera changes. This element also 
+  # includes specifications for stacking order of multiple overlays and for adding color and transparency values to 
+  # the base image.
+  class Overlay < Feature
+    attr_accessor :color
+    attr_accessor :draw_order
+    attr_accessor :icon
+    
+    def render(xm=Builder::XmlMarkup.new(:indent => 2))
+      super
+      xm.color(color) unless color.nil?
+      xm.drawOrder(drawOrder) unless draw_order.nil?
+      icon.render(xm) unless icon.nil?
+    end
+  end
+end
+
+require 'kml/ground_overlay'
+require 'kml/screen_overlay'

data/lib/kml/placemark.rb

@@ -0,0 +1,60 @@
+# Basic XML Structure:
+#
+#   <Placemark id="ID">
+#     <!-- inherited from Feature element -->
+#     <name>...</name>                      <!-- string -->
+#     <visibility>1</visibility>            <!-- boolean -->
+#     <open>1</open>                        <!-- boolean -->
+#     <address>...</address>                <!-- string -->
+#     <AddressDetails xmlns="urn:oasis:names:tc:ciq:xsdschema:xAL:2.0">...
+#         </AddressDetails>                 <!-- string -->
+#     <phoneNumber>...</phoneNumber>        <!-- string -->
+#     <Snippet maxLines="2">...</Snippet>   <!-- string -->
+#     <description>...</description>        <!-- string -->
+#     <LookAt>...</LookAt>
+#     <TimePrimitive>...</TimePrimitive>
+#     <styleUrl>...</styleUrl>              <!-- anyURI -->
+#     <StyleSelector>...</StyleSelector>
+#     <Region>...</Region>
+#     <Metadata>...</Metadata>
+#
+#     <!-- specific to Placemark element -->
+#     <Geometry>...</Geometry>
+#   </Placemark>
+
+module KML
+  class Placemark < KML::Container
+    attr_accessor :geometry
+
+    def render(xm=Builder::XmlMarkup.new(:indent => 2))
+      xm.Placemark {
+        super
+        features.each { |f| f.render(xm) }
+        plain_children.each { |c| xm << c }
+        geometry.render(xm) unless geometry.nil?
+      }
+    end
+
+    def self.parse(node)
+      self.new.parse(node)
+    end
+
+    def parse(node)
+      super(node) do |cld|
+        case cld.name
+        when 'MultiGeometry'
+          self.geometry = KML::MultiGeometry.parse(cld)
+        when 'Polygon'
+          self.geometry = KML::Polygon.parse(cld)
+        when 'Point'
+          self.geometry = KML::Point.parse(cld)
+        else
+          puts "Placemark"
+          p cld
+          puts
+        end
+      end
+      self
+    end
+  end
+end

data/lib/kml/point.rb

@@ -0,0 +1,65 @@
+# <Point id="ID">
+#   <!-- specific to Point -->
+#   <extrude>0</extrude>                   <!-- boolean -->
+#   <tessellate>0</tessellate>             <!-- boolean -->
+#   <altitudeMode>clampToGround</altitudeMode> 
+#     <!-- kml:altitudeModeEnum: clampToGround, relativeToGround, or absolute -->
+#   <coordinates>...</coordinates>         <!-- lon,lat[,alt] -->
+# </Point>
+module KML
+  class Point < Geometry
+
+    # A single tuple consisting of floating point values for longitude, latitude, and altitude (in that order). 
+    # Longitude and latitude values are in degrees, where:
+    #
+    # * longitude >= -180 and <= 180
+    # * latitude >= -90 and <= 90
+    # * altitude values (optional) are in meters above sea level
+    def coordinates
+      @coordinates
+    end
+
+    # Set the coordinates
+    def coordinates=(c)
+      case c
+      when String
+        @coordinates = c.strip.split(',')
+        unless @coordinates.length == 2 || @coordinates.length == 3
+          raise "Coordinates string may only have 2 parts (indicating lat and long) or 3 parts (lat, long and altitude)"
+        end
+      when Array
+        @coordinates = c
+      when Hash
+        @coordinates = [:lng, :lat, :alt].collect {|attr| c[attr]}.compact
+      else
+        raise ArgumentError, "Coordinates must be either a String, Hash or an Array"
+      end
+    end
+
+    def render(xm=Builder::XmlMarkup.new(:indent => 2))
+      xm.Point {
+        super
+        xm.coordinates(coordinates.join(","))
+      }
+    end
+
+    def self.parse(node)
+      self.new.parse(node)
+    end
+
+    def parse(node)
+      super(node) do |cld|
+        case cld.name
+        when 'coordinates'
+          self.coordinates = cld.content
+        else
+          puts "Point"
+          p cld
+          puts
+        end
+      end
+      self
+    end
+
+  end
+end

data/lib/kml/poly_style.rb

@@ -0,0 +1,16 @@
+module KML
+  # Specifies the drawing style for all polygons, including polygon extrusions (which look like the walls of buildings) 
+  # and line extrusions (which look like solid fences).
+  class PolyStyle < ColorStyle
+    attr_accessor :fill
+    attr_accessor :outline
+    
+    def render(xm=Builder::XmlMarkup.new(:indent => 2))
+      xm.PolyStyle {
+        super
+        xm.fill(fill) unless fill.nil?
+        xm.outline(outline) unless outline.nil?
+      }
+    end
+  end
+end

data/lib/kml/polygon.rb

@@ -0,0 +1,91 @@
+# Source file which generates a Polygon element.
+#
+# <Polygon id="ID">
+#   <!-- specific to Polygon -->
+#   <extrude>0</extrude>                       <!-- boolean -->
+#   <tessellate>0</tessellate>                 <!-- boolean -->
+#   <altitudeMode>clampToGround</altitudeMode> 
+#     <!-- kml:altitudeModeEnum: clampToGround, relativeToGround, or absolute -->
+#   <outerBoundaryIs>
+#     <LinearRing>
+#       <coordinates>...</coordinates>         <!-- lon,lat[,alt] -->
+#     </LinearRing>
+#   </outerBoundaryIs>
+#   <innerBoundaryIs>
+#     <LinearRing>
+#       <coordinates>...</coordinates>         <!-- lon,lat[,alt] -->
+#     </LinearRing>
+#   </innerBoundaryIs>
+#   <innerBoundaryIs>
+#     ...
+#   </innerBoundaryIs>
+# </Polygon>
+
+module KML #:nodoc:
+  # A Polygon is defined by an outer boundary and 0 or more inner boundaries. The boundaries, in turn, are defined 
+  # by LinearRings. When a Polygon is extruded, its boundaries are connected to the ground to form additional polygons, 
+  # which gives the appearance of a building. When a Polygon is extruded, each point is extruded individually. 
+  # Extruded Polygons use PolyStyle for their color, color mode, and fill.
+  class Polygon < Geometry
+    attr_accessor :outer_boundary_is
+
+    def inner_boundary_is
+      @inner_boundary_is ||= []
+    end
+
+    # allow old semantics for adding inner boundaries
+    def inner_boundary_is=(ib)
+      if ib.kind_of?(Array)
+        @inner_boundary_is = ib
+      else
+        self.inner_boundary_is << ib
+      end
+    end
+
+    def render(xm=Builder::XmlMarkup.new(:indent => 2))
+      xm.Polygon {
+        super
+        xm.outerBoundaryIs {
+          outer_boundary_is.render(xm)
+        }
+        inner_boundary_is.each do |ib|
+          xm.innerBoundaryIs {
+            ib.render(xm)
+          }
+        end
+      }
+    end
+
+    def self.parse(node)
+      self.new.parse(node)
+    end
+
+    def parse(node)
+      super(node) do |cld|
+        case cld.name
+        when 'outerBoundaryIs'
+          self.outer_boundary_is = self.parse_boundary(cld)
+        when 'innerBoundaryIs'
+          self.inner_boundary_is << self.parse_boundary(cld)
+        else
+          puts "Polygon"
+          p cld
+          puts
+        end
+      end
+      self
+    end
+
+    # should only contain a LinearRing
+    def parse_boundary(node)
+      ring = nil
+      node.element_children.each do |cld|
+        case cld.name
+        when 'LinearRing'
+          ring = KML::LinearRing.parse(cld)
+        end
+      end
+      ring
+    end
+  end
+end

data/lib/kml/screen_overlay.rb

@@ -0,0 +1,61 @@
+# This file implements the ScreenOverlay type
+# <ScreenOverlay id="ID">
+#   <!-- inherited from Feature element -->
+#   <!-- inherited from Overlay element -->
+# 
+#   <!-- specific to ScreenOverlay -->
+#   <overlayXY x="double" y="double" xunits="fraction" yunits="fraction"/>    
+#     <!-- vec2 -->
+#     <!-- xunits and yunits can be one of: fraction, pixels, or insetPixels -->
+#   <screenXY x="double" y="double" xunits="fraction" yunits="fraction"/>      
+#     <!-- vec2 -->
+#   <rotationXY x="double" y="double" xunits="fraction" yunits"fraction"/>  
+#     <!-- vec2 -->
+#   <size x="double" y="double" xunits="fraction" yunits="fraction"/>              
+#     <!-- vec2 --> 
+#   <rotation>0</rotation>                   <!-- float -->
+#  </ScreenOverlay>
+
+module KML
+
+  class ScreenOverlay < Overlay
+    
+    # A hash of options in the form of {:x, :y, :xunits, :yunits} that
+    # specify the point on the overlay image that is mapped to the screen
+    def overlay_xy
+      @overlay_xy
+    end
+
+    # Set the overlay_xy coordinates
+    #
+    # xunits and yunits are :pixels or :fraction
+    def overlay_xy= coords
+      @overlay_xy = {:xunits => :fraction, :yunits => :fraction}.merge(coords)
+    end
+
+    # A hash of options in the form of {:x, :y, :xunits, :yunits} that
+    # specify the position on the screen where the image is mapped
+    def screen_xy
+      @screen_xy
+    end
+
+    #Set the screen_xy coordinates
+    #
+    # xunits and yunits are :pixels or :fraction
+    def screen_xy= coords
+      @screen_xy = {:xunits => :fraction, :yunits => :fraction}.merge(coords)
+    end
+
+    attr_accessor :size, :rotation
+
+    def render(xm=Builder::XmlMarkup.new(:indent => 2))
+      xm.ScreenOverlay {
+        super
+        xm.overlayXY(@overlay_xy) if @overlay_xy
+        xm.screenXY(@screen_xy) if @screen_xy
+        xm.size{ @size } if @size
+        xm.rotation{ @rotation } if @rotation
+      }
+    end
+  end
+end

data/lib/kml/snippet.rb

@@ -0,0 +1,25 @@
+module KML #:nodoc:
+  # A short description of a feature. In Google Earth, this description is displayed in the Places panel 
+  # under the name of the feature. If a Snippet is not supplied, the first two lines of the description are 
+  # used. In Google Earth, if a Placemark contains both a description and a Snippet, the Snippet appears 
+  # beneath the Placemark in the Places panel, and the description appears in the Placemark's description 
+  # balloon. This object does not support HTML markup.
+  class Snippet
+    # The maximum number of lines to display.
+    attr_accessor :max_lines
+    
+    # The text that is displayed (HTML not supported)
+    attr_accessor :text
+    
+    # Initialize the snippet with the given text and optionally with the given max_lines value.
+    def initialize(text, max_lines=nil)
+      @text = text
+      @max_lines = max_lines
+    end
+    
+    # The maximum number of lines to display. Default is 2
+    def max_lines
+      @max_lines ||= 2
+    end
+  end
+end