rgeo-kml 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 06227b992bdd5a2c5169650431585db1648c8b04
+  data.tar.gz: df4e6c62b71585076ddafef8721e85f770b4f871
+SHA512:
+  metadata.gz: 4fb3bb15dd469492f7dda89d9a6141441531e9afa19f3166ba40d253a690ad1b56df2fb212d11276cf3a7979bd1fce0831653bd9f16d42ae1225e0e3a4804c3d
+  data.tar.gz: 786a6e34ea432784590336be029e4e466ea47ad8d3644701ce2693155953edfcd2a1afb4daf6581525ec9f4577d70fe097230377db22f71fb2f26b6e0533bfba

data/Version

@@ -0,0 +1 @@
+0.0.1

data/lib/rgeo-kml.rb

@@ -0,0 +1,7 @@
+# -----------------------------------------------------------------------------
+#
+# Kml implementation for RGeo
+#
+# -----------------------------------------------------------------------------
+
+require 'rgeo/kml'

data/lib/rgeo/kml.rb

@@ -0,0 +1,39 @@
+# -----------------------------------------------------------------------------
+#
+# Kml implementation for RGeo
+#
+# -----------------------------------------------------------------------------
+
+# Dependencies
+require 'rgeo'
+
+# RGeo is a spatial data library for Ruby, provided by the "rgeo" gem.
+#
+# The optional RGeo::GeoJSON module provides a set of tools for GeoJSON
+# encoding and decoding.
+
+module RGeo
+
+
+  # This is a namespace for a set of tools that provide KML encoding.
+  # See https://developers.google.com/kml/documentation/ for more information about this specification.
+
+  module Kml
+  end
+
+
+end
+
+
+# Implementation files
+require 'rgeo/kml/version'
+require 'rgeo/kml/entities'
+require 'rgeo/kml/coder'
+require 'rgeo/kml/interface'
+require 'rgeo/kml/kml_stream_listener'
+require 'rgeo/kml/coordinates_builder'
+require 'rgeo/kml/point_builder'
+require 'rgeo/kml/line_string_builder'
+require 'rgeo/kml/linear_ring_builder'
+require 'rgeo/kml/polygon_builder'
+require 'rgeo/kml/multi_geometry_builder'

data/lib/rgeo/kml/coder.rb

@@ -0,0 +1,222 @@
+# -----------------------------------------------------------------------------
+#
+# Kml encoder object
+#
+# -----------------------------------------------------------------------------
+
+require "rexml/document"
+require 'rexml/parsers/pullparser'
+
+module RGeo
+
+  module Kml
+
+
+    # This object encapsulates encoding and decoding settings (principally
+    # the RGeo::Feature::Factory and the RGeo::Kml::EntityFactory to
+    # be used) so that you can encode and decode without specifying those
+    # settings every time.
+
+    class Coder
+
+      ELEMENT_MAP = {
+      'Point' => "point",
+      'LineString' => "line_string",
+      'LinearRing' => "linear_ring",
+      'Polygon' => "polygon",
+      'MultiGeometry' => "geometry_collection"
+      }
+
+      @@kml_available = nil
+      @@activesupport_available = nil
+
+
+      # Create a new coder settings object. The geo factory is passed as
+      # a required argument.
+      #
+      # Options include:
+      #
+      # [<tt>:geo_factory</tt>]
+      #   Specifies the geo factory to use to create geometry objects.
+      #   Defaults to the preferred cartesian factory.
+      # [<tt>:entity_factory</tt>]
+      #   Specifies an entity factory, which lets you override the types
+      #   of Kml entities that are created. It defaults to the default
+      #   RGeo::Kml::EntityFactory, which generates objects of type
+      #   RGeo::Kml::Feature or RGeo::Kml::FeatureCollection.
+      #   See RGeo::Kml::EntityFactory for more information.
+
+      def initialize(opts_={})
+        @geo_factory = opts_[:geo_factory] || ::RGeo::Cartesian.preferred_factory
+        @entity_factory = opts_[:entity_factory] || EntityFactory.instance
+        @buffer = ''
+        
+        @num_coordinates = 2
+        @num_coordinates += 1 if @geo_factory.property(:has_z_coordinate)
+        @num_coordinates += 1 if @geo_factory.property(:has_m_coordinate)
+      end
+
+
+      # Encode the given object as Kml. The object may be one of the
+      # geometry objects specified in RGeo::Feature, or an appropriate
+      # Kml wrapper entity supported by this coder's entity factory.
+      #
+      # This method returns a KML object (xml with Placemark).
+      #
+      # Returns nil if nil is passed in as the object.
+
+      def encode(object_)
+        if @entity_factory.is_feature_collection?(object_)
+          {
+            'type' => 'FeatureCollection',
+            'features' => @entity_factory.map_feature_collection(object_){ |f_| _encode_feature(f_) },
+          }
+        elsif @entity_factory.is_feature?(object_)
+          _encode_feature(object_)
+        elsif object_.nil?
+          nil
+        else
+          _encode_geometry(object_)
+        end
+      end
+
+      
+      # Returns the RGeo::Feature::Factory used to generate geometry objects.
+
+      def geo_factory
+        @geo_factory
+      end
+
+
+      # Returns the RGeo::Kml::EntityFactory used to generate Kml
+      # wrapper entities.
+
+      def entity_factory
+        @entity_factory
+      end
+
+
+      def _encode_feature(object_)  # :nodoc:
+        id_ = @entity_factory.get_feature_id(object_)
+        kml_ = '<?xml version="1.0" encoding="UTF-8"?>\n'
+        kml_ += '<kml xmlns="http://www.opengis.net/kml/2.2">\n'
+        kml_ += "<Document>"
+        kml_ += "<name>Kml File</name>"
+        kml_ += "<Placemark id="#{id_}">\n"
+        kml_ += _encode_geometry(@entity_factory.get_feature_geometry(object_))
+        kml_ += "</Placemark>\n"
+        kml_ += "</Document>"
+        kml_ += "</kml>"
+        
+        # 'properties' => @entity_factory.get_feature_properties(object_).dup,        
+        # id_ = @entity_factory.get_feature_id(object_)
+        # json_['id'] = id_ if id_
+        kml_
+      end
+
+
+      def _encode_geometry(object_, point_encoder_=nil)  # :nodoc:
+        unless point_encoder_
+          if object_.factory.property(:has_z_coordinate)
+            if object_.factory.property(:has_m_coordinate)
+              point_encoder_ = ::Proc.new{ |p_| [p_.x, p_.y, p_.z, p_.m].join(",") }
+            else
+              point_encoder_ = ::Proc.new{ |p_| [p_.x, p_.y, p_.z].join(",") }
+            end
+          else
+            if object_.factory.property(:has_m_coordinate)
+              point_encoder_ = ::Proc.new{ |p_| [p_.x, p_.y, p_.m].join(",") }
+            else
+              point_encoder_ = ::Proc.new{ |p_| [p_.x, p_.y].join(",") }
+            end
+          end
+        end
+        case object_
+        when ::RGeo::Feature::Point
+          result = "<Point>\n"
+          #result += options[:geom_data] if options[:geom_data]
+          result += "<coordinates>" + point_encoder_.call(object_)
+          result += "</coordinates>\n"
+          result += "</Point>\n"
+        when ::RGeo::Feature::LineString
+          result = "<LineString>\n"
+          #result += options[:geom_data] if options[:geom_data]
+          result += "<coordinates>\n"
+          result += object_.points.map(&point_encoder_).join("\n")
+          result += "\n</coordinates>\n"
+          result += "</LineString>\n"
+        when ::RGeo::Feature::Polygon
+          result = "<Polygon>\n"
+          #result += options[:geom_data] if options[:geom_data]
+          result += "<outerBoundaryIs><LinearRing><coordinates>\n"
+          result += object_.exterior_ring.points.map(&point_encoder_).join("\n")
+          result += "\n</coordinates></LinearRing></outerBoundaryIs>\n"
+          object_.interior_rings.each do |interior_ring|
+            result += "<innerBoundaryIs><LinearRing><coordinates>\n"
+            result += interior_ring.points.map(&point_encoder_).join("\n")
+            result += "\n</coordinates></LinearRing></innerBoundaryIs>\n"
+          end
+          result += "</Polygon>\n"
+        when ::RGeo::Feature::MultiPoint
+          result = "<MultiGeometry>\n"
+          object_.each do |geometry|
+            result += "<Point>\n<coordinates>"
+            #options[:id_attr] = "" #the subgeometries do not have an ID
+            result += point_encoder_.call(geometry)
+            result += "</coordinates>\n</Point>\n"
+          end
+          result += "</MultiGeometry>\n"
+        when ::RGeo::Feature::MultiLineString
+          result = "<MultiGeometry>\n"
+          object_.each do |geometry|
+            #options[:id_attr] = "" #the subgeometries do not have an ID
+            result += "<LineString>\n"
+            #result += options[:geom_data] if options[:geom_data]
+            result += "<coordinates>\n"
+            result += geometry.points.map(&point_encoder_).join("\n")
+            result += "\n</coordinates>\n"
+            result += "</LineString>\n"            
+          end
+          result += "</MultiGeometry>\n"
+        when ::RGeo::Feature::MultiPolygon
+          result = "<MultiGeometry>\n"
+          object_.each do |geometry|
+            #options[:id_attr] = "" #the subgeometries do not have an ID
+            result += "<Polygon>\n"
+            #result += options[:geom_data] if options[:geom_data]
+           result += "<outerBoundaryIs><LinearRing><coordinates>\n"
+            result += geometry.exterior_ring.points.map(&point_encoder_).join("\n")
+            result += "\n</coordinates></LinearRing></outerBoundaryIs>\n"
+            geometry.interior_rings.each do |interior_ring|
+              result += "<innerBoundaryIs><LinearRing><coordinates>\n"
+              result += interior_ring.points.map(&point_encoder_).join("\n")
+              result += "\n</coordinates></LinearRing></innerBoundaryIs>\n"
+            end
+            result += "</Polygon>\n"
+          end
+          result += "</MultiGeometry>\n"
+        when ::RGeo::Feature::GeometryCollection
+          result = "<MultiGeometry>\n"          
+          #options[:id_attr] = "" #the subgeometries do not have an ID
+          result += object_.map{ |geom_| _encode_geometry(geom_, point_encoder_) }.join("")
+          result += "</MultiGeometry>\n"
+        else
+          nil
+        end
+      end
+
+
+      # Decode an object from Kml. The input may a
+      # String, or an IO object from which to read the KML string.
+      # If an error occurs, nil is returned.
+      def decode(input_) 
+        @kml_stream_listener = KmlStreamListener.new(geo_factory)
+        @kml_stream_listener.parse(input_)
+        @kml_stream_listener.result
+      end
+
+    end     
+
+  end
+
+end

data/lib/rgeo/kml/coordinates_builder.rb

@@ -0,0 +1,37 @@
+module RGeo
+  module Kml
+    
+    class CoordinatesBuilder
+      attr_reader :geo_factory, :parent, :points
+      attr_accessor :text
+      
+      def initialize( geo_factory, parent)
+        @geo_factory = geo_factory
+        @parent = parent
+        @points = []
+      end
+
+      def build
+        @text.gsub(/\n/, ' ').strip.split(/\s+/).each do |coord|
+          x, y, z = coord.split(',')
+          if x.nil? || y.nil?
+            fail StandardError, 'Coordinates must have at least x and y elements'
+          end
+          if z.nil?
+            @points << @geo_factory.point(x, y)
+          else
+            @points << @geo_factory.point(x, y, z)
+          end
+
+          @points
+        end
+        
+      rescue Exception => e
+        puts "Exception #{e.message} \n #{e.backtrace}"
+        raise StandardError, 'Error parsing coordinates: check your kml for errors'
+      end
+      
+    end
+
+  end
+end

data/lib/rgeo/kml/entities.rb

@@ -0,0 +1,275 @@
+# -----------------------------------------------------------------------------
+#
+# Kml standard entities
+#
+# -----------------------------------------------------------------------------
+
+
+module RGeo
+
+  module Kml
+
+
+    # This is a Kml wrapper entity that corresponds to the Kml
+    # "Feature" type. It is an immutable type.
+    #
+    # This is the default implementation that is generated by
+    # RGeo::Kml::EntityFactory. You may replace this implementation
+    # by writing your own entity factory. Note that an alternate Feature
+    # implementation need not subclass or even duck-type this class.
+    # the entity factory mediates all interaction between the Kml
+    # engine and features.
+
+    class Feature
+
+
+      # Create a feature wrapping the given geometry, with the given ID
+      # and properties.
+
+      def initialize(geometry_, id_=nil, properties_={})
+        @geometry = geometry_
+        @id = id_
+        @properties = {}
+        properties_.each do |k_, v_|
+          @properties[k_.to_s] = v_
+        end
+      end
+
+
+      def inspect  # :nodoc:
+        "#<#{self.class}:0x#{object_id.to_s(16)} id=#{@id.inspect} geom=#{@geometry ? @geometry.as_text.inspect : 'nil'}>"
+      end
+
+      def to_s  # :nodoc:
+        inspect
+      end
+
+      def hash  # :nodoc:
+        @geometry.hash + @id.hash + @properties.hash
+      end
+
+
+      # Two features are equal if their geometries, IDs, and properties
+      # are all equal.
+      # This method uses the eql? method to test geometry equality, which
+      # may behave differently than the == operator.
+
+      def eql?(rhs_)
+        rhs_.kind_of?(Feature) && @geometry.eql?(rhs_.geometry) && @id.eql?(rhs_.feature_id) && @properties.eql?(rhs_.instance_variable_get(:@properties))
+      end
+
+
+      # Two features are equal if their geometries, IDs, and properties
+      # are all equal.
+      # This method uses the == operator to test geometry equality, which
+      # may behave differently than the eql? method.
+
+      def ==(rhs_)
+        rhs_.kind_of?(Feature) && @geometry == rhs_.geometry && @id == rhs_.feature_id && @properties == rhs_.instance_variable_get(:@properties)
+      end
+
+
+      # Returns the geometry contained in this feature, which may be nil.
+
+      def geometry
+        @geometry
+      end
+
+
+      # Returns the ID for this feature, which may be nil.
+
+      def feature_id
+        @id
+      end
+
+
+      # Returns a copy of the properties for this feature.
+
+      def properties
+        @properties.dup
+      end
+
+
+      # Gets the value of the given named property.
+      # Returns nil if the given property is not found.
+
+      def property(key_)
+        @properties[key_.to_s]
+      end
+      alias_method :[], :property
+
+
+      # Gets an array of the known property keys in this feature.
+
+      def keys
+        @properties.keys
+      end
+
+
+    end
+
+
+    # This is a Kml wrapper entity that corresponds to the Kml
+    # "FeatureCollection" type. It is an immutable type.
+    #
+    # This is the default implementation that is generated by
+    # RGeo::Kml::EntityFactory. You may replace this implementation
+    # by writing your own entity factory. Note that an alternate
+    # FeatureCollection implementation need not subclass or even
+    # duck-type this class. The entity factory mediates all interaction
+    # between the Kml engine and feature collections.
+
+    class FeatureCollection
+
+      include ::Enumerable
+
+
+      # Create a new FeatureCollection with the given features, which must
+      # be provided as an Enumerable.
+
+      def initialize(features_=[])
+        @features = []
+        features_.each{ |f_| @features << f_ if f_.kind_of?(Feature) }
+      end
+
+
+      def inspect  # :nodoc:
+        "#<#{self.class}:0x#{object_id.to_s(16)}>"
+      end
+
+      def to_s  # :nodoc:
+        inspect
+      end
+
+      def hash  # :nodoc:
+        @features.hash
+      end
+
+
+      # Two feature collections are equal if they contain the same
+      # features in the same order.
+      # This methods uses the eql? method to test geometry equality, which
+      # may behave differently than the == operator.
+
+      def eql?(rhs_)
+        rhs_.kind_of?(FeatureCollection) && @features.eql?(rhs_.instance_variable_get(:@features))
+      end
+
+
+      # Two feature collections are equal if they contain the same
+      # features in the same order.
+      # This methods uses the == operator to test geometry equality, which
+      # may behave differently than the eql? method.
+
+      def ==(rhs_)
+        rhs_.kind_of?(FeatureCollection) && @features == rhs_.instance_variable_get(:@features)
+      end
+
+
+      # Iterates or returns an iterator for the features.
+
+      def each(&block_)
+        @features.each(&block_)
+      end
+
+
+      # Returns the number of features contained in this collection.
+
+      def size
+        @features.size
+      end
+
+
+      # Access a feature by index.
+
+      def [](index_)
+        @features[index_]
+      end
+
+
+    end
+
+
+    # This is the default entity factory. It creates objects of type
+    # RGeo::Kml::Feature and RGeo::Kml::FeatureCollection.
+    # You may create your own entity factory by duck-typing this class.
+
+    class EntityFactory
+
+
+      # Create and return a new feature, given geometry, ID, and
+      # properties hash. Note that, per the Kml spec, geometry and/or
+      # properties may be nil.
+
+      def feature(geometry_, id_=nil, properties_=nil)
+        Feature.new(geometry_, id_, properties_ || {})
+      end
+
+
+      # Create and return a new feature collection, given an enumerable
+      # of feature objects.
+
+      def feature_collection(features_=[])
+        FeatureCollection.new(features_)
+      end
+
+
+      # Returns true if the given object is a feature created by this
+      # entity factory.
+
+      def is_feature?(object_)
+        object_.kind_of?(Feature)
+      end
+
+
+      # Returns true if the given object is a feature collection created
+      # by this entity factory.
+
+      def is_feature_collection?(object_)
+        object_.kind_of?(FeatureCollection)
+      end
+
+
+      # Run Enumerable#map on the features contained in the given feature
+      # collection.
+
+      def map_feature_collection(object_, &block_)
+        object_.map(&block_)
+      end
+
+
+      # Returns the geometry associated with the given feature.
+
+      def get_feature_geometry(object_)
+        object_.geometry
+      end
+
+
+      # Returns the ID of the given feature, or nil for no ID.
+
+      def get_feature_id(object_)
+        object_.feature_id
+      end
+
+
+      # Returns the properties of the given feature as a hash. Editing
+      # this hash does not change the state of the feature.
+
+      def get_feature_properties(object_)
+        object_.properties
+      end
+
+
+      # Return the singleton instance of EntityFactory.
+
+      def self.instance
+        @instance ||= self.new
+      end
+
+
+    end
+
+
+  end
+
+end