rgeo-dschee 0.5.4

data/lib/rgeo/version.rb

@@ -0,0 +1,3 @@
+module RGeo
+  VERSION = "0.5.4".freeze
+end

data/lib/rgeo/wkrep.rb

@@ -0,0 +1,37 @@
+# -----------------------------------------------------------------------------
+#
+# Well-known representation for RGeo
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  # This module contains implementations of the OpenGIS well-known
+  # representations: the WKT (well-known text representation) and the
+  # WKB (well-known binary representation), as defined in the Simple
+  # Features Specification, version 1.1. Facilities are provided to
+  # serialize any geometry into one of these formats, and to parse a
+  # serialized string back into a geometry. Support is also provided for
+  # the common extensions to these formats-- notably, the EWKT and EWKB
+  # formats used by PostGIS.
+  #
+  # To serialize a geometry into WKT (well-known text) format, use
+  # the WKRep::WKTGenerator class.
+  #
+  # To serialize a geometry into WKB (well-known binary) format, use
+  # the WKRep::WKBGenerator class.
+  #
+  # To parse a string in WKT (well-known text) format back into a
+  # geometry object, use the WKRep::WKTParser class.
+  #
+  # To parse a byte string in WKB (well-known binary) format back into a
+  # geometry object, use the WKRep::WKBParser class.
+
+  module WKRep
+  end
+end
+
+# Implementation files
+require "rgeo/wkrep/wkt_parser"
+require "rgeo/wkrep/wkt_generator"
+require "rgeo/wkrep/wkb_parser"
+require "rgeo/wkrep/wkb_generator"

data/lib/rgeo/wkrep/wkb_generator.rb

@@ -0,0 +1,201 @@
+# -----------------------------------------------------------------------------
+#
+# Well-known binary generator for RGeo
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module WKRep
+    # This class provides the functionality of serializing a geometry as
+    # WKB (well-known binary) format. You may also customize the
+    # serializer to generate PostGIS EWKB extensions to the output, or to
+    # follow the Simple Features Specification 1.2 extensions for Z and M
+    # coordinates.
+    #
+    # To use this class, create an instance with the desired settings and
+    # customizations, and call the generate method.
+    #
+    # === Configuration options
+    #
+    # The following options are recognized. These can be passed to the
+    # constructor, or set on the object afterwards.
+    #
+    # [<tt>:type_format</tt>]
+    #   The format for type codes. Possible values are <tt>:wkb11</tt>,
+    #   indicating SFS 1.1 WKB (i.e. no Z or M values); <tt>:ewkb</tt>,
+    #   indicating the PostGIS EWKB extensions (i.e. Z and M presence
+    #   flagged by the two high bits of the type code, and support for
+    #   embedded SRID); or <tt>:wkb12</tt> (indicating SFS 1.2 WKB
+    #   (i.e. Z and M presence flagged by adding 1000 and/or 2000 to
+    #   the type code.) Default is <tt>:wkb11</tt>.
+    # [<tt>:emit_ewkb_srid</tt>]
+    #   If true, embed the SRID in the toplevel geometry. Available only
+    #   if <tt>:type_format</tt> is <tt>:ewkb</tt>. Default is false.
+    # [<tt>:hex_format</tt>]
+    #   If true, output a hex string instead of a byte string.
+    #   Default is false.
+    # [<tt>:little_endian</tt>]
+    #   If true, output little endian (NDR) byte order. If false, output
+    #   big endian (XDR), or network byte order. Default is false.
+
+    class WKBGenerator
+      # :stopdoc:
+      TYPE_CODES = {
+        Feature::Point => 1,
+        Feature::LineString => 2,
+        Feature::LinearRing => 2,
+        Feature::Line => 2,
+        Feature::Polygon => 3,
+        Feature::MultiPoint => 4,
+        Feature::MultiLineString => 5,
+        Feature::MultiPolygon => 6,
+        Feature::GeometryCollection => 7
+      }.freeze
+      # :startdoc:
+
+      # Create and configure a WKB generator. See the WKBGenerator
+      # documentation for the options that can be passed.
+
+      def initialize(opts_ = {})
+        @type_format = opts_[:type_format] || :wkb11
+        @emit_ewkb_srid = @type_format == :ewkb ?
+          (opts_[:emit_ewkb_srid] ? true : false) : nil
+        @hex_format = opts_[:hex_format] ? true : false
+        @little_endian = opts_[:little_endian] ? true : false
+      end
+
+      # Returns the format for type codes. See WKBGenerator for details.
+      attr_reader :type_format
+
+      # Returns whether SRID is embedded. See WKBGenerator for details.
+      def emit_ewkb_srid?
+        @emit_ewkb_srid
+      end
+
+      # Returns whether output is converted to hex.
+      # See WKBGenerator for details.
+      def hex_format?
+        @hex_format
+      end
+
+      # Returns whether output is little-endian (NDR).
+      # See WKBGenerator for details.
+      def little_endian?
+        @little_endian
+      end
+
+      def _properties # :nodoc:
+        {
+          "type_format" => @type_format.to_s,
+          "emit_ewkb_srid" => @emit_ewkb_srid,
+          "hex_format" => @hex_format,
+          "little_endian" => @little_endian
+        }
+      end
+
+      # Generate and return the WKB format for the given geometry object,
+      # according to the current settings.
+
+      def generate(obj_)
+        factory_ = obj_.factory
+        if @type_format == :ewkb || @type_format == :wkb12
+          @cur_has_z = factory_.property(:has_z_coordinate)
+          @cur_has_m = factory_.property(:has_m_coordinate)
+        else
+          @cur_has_z = nil
+          @cur_has_m = nil
+        end
+        @cur_dims = 2 + (@cur_has_z ? 1 : 0) + (@cur_has_m ? 1 : 0)
+        _start_emitter
+        _generate_feature(obj_, true)
+        _finish_emitter
+      end
+
+      def _generate_feature(obj_, toplevel_ = false) # :nodoc:
+        _emit_byte(@little_endian ? 1 : 0)
+        type_ = obj_.geometry_type
+        type_code_ = TYPE_CODES[type_]
+        unless type_code_
+          raise Error::ParseError, "Unrecognized Geometry Type: #{type_}"
+        end
+        emit_srid_ = false
+        if @type_format == :ewkb
+          type_code_ |= 0x80000000 if @cur_has_z
+          type_code_ |= 0x40000000 if @cur_has_m
+          if @emit_ewkb_srid && toplevel_
+            type_code_ |= 0x20000000
+            emit_srid_ = true
+          end
+        elsif @type_format == :wkb12
+          type_code_ += 1000 if @cur_has_z
+          type_code_ += 2000 if @cur_has_m
+        end
+        _emit_integer(type_code_)
+        _emit_integer(obj_.srid) if emit_srid_
+        if type_ == Feature::Point
+          _emit_doubles(_point_coords(obj_))
+        elsif type_.subtype_of?(Feature::LineString)
+          _emit_line_string_coords(obj_)
+        elsif type_ == Feature::Polygon
+          exterior_ring_ = obj_.exterior_ring
+          if exterior_ring_.is_empty?
+            _emit_integer(0)
+          else
+            _emit_integer(1 + obj_.num_interior_rings)
+            _emit_line_string_coords(exterior_ring_)
+            obj_.interior_rings.each { |r_| _emit_line_string_coords(r_) }
+          end
+        elsif type_ == Feature::GeometryCollection
+          _emit_integer(obj_.num_geometries)
+          obj_.each { |g_| _generate_feature(g_) }
+        elsif type_ == Feature::MultiPoint
+          _emit_integer(obj_.num_geometries)
+          obj_.each { |g_| _generate_feature(g_) }
+        elsif type_ == Feature::MultiLineString
+          _emit_integer(obj_.num_geometries)
+          obj_.each { |g_| _generate_feature(g_) }
+        elsif type_ == Feature::MultiPolygon
+          _emit_integer(obj_.num_geometries)
+          obj_.each { |g_| _generate_feature(g_) }
+        end
+      end
+
+      def _point_coords(obj_, array_ = []) # :nodoc:
+        array_ << obj_.x
+        array_ << obj_.y
+        array_ << obj_.z if @cur_has_z
+        array_ << obj_.m if @cur_has_m
+        array_
+      end
+
+      def _emit_line_string_coords(obj_) # :nodoc:
+        array_ = []
+        obj_.points.each { |p_| _point_coords(p_, array_) }
+        _emit_integer(obj_.num_points)
+        _emit_doubles(array_)
+      end
+
+      def _start_emitter # :nodoc:
+        @cur_array = []
+      end
+
+      def _emit_byte(value_) # :nodoc:
+        @cur_array << [value_].pack("C")
+      end
+
+      def _emit_integer(value_)  # :nodoc:
+        @cur_array << [value_].pack(@little_endian ? "V" : "N")
+      end
+
+      def _emit_doubles(array_)  # :nodoc:
+        @cur_array << array_.pack(@little_endian ? "E*" : "G*")
+      end
+
+      def _finish_emitter # :nodoc:
+        str_ = @cur_array.join
+        @cur_array = nil
+        @hex_format ? str_.unpack("H*")[0] : str_
+      end
+    end
+  end
+end

data/lib/rgeo/wkrep/wkb_parser.rb

@@ -0,0 +1,251 @@
+# -----------------------------------------------------------------------------
+#
+# Well-known binary parser for RGeo
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module WKRep
+    # This class provides the functionality of parsing a geometry from
+    # WKB (well-known binary) format. You may also customize the parser
+    # to recognize PostGIS EWKB extensions to the input, or Simple
+    # Features Specification 1.2 extensions for Z and M coordinates.
+    #
+    # To use this class, create an instance with the desired settings and
+    # customizations, and call the parse method.
+    #
+    # === Configuration options
+    #
+    # You must provide each parser with an RGeo::Feature::FactoryGenerator.
+    # It should understand the configuration options <tt>:srid</tt>,
+    # <tt>:has_z_coordinate</tt>, and <tt>:has_m_coordinate</tt>.
+    # You may also pass a specific RGeo::Feature::Factory, or nil to
+    # specify the default Cartesian FactoryGenerator.
+    #
+    # The following additional options are recognized. These can be passed
+    # to the constructor, or set on the object afterwards.
+    #
+    # [<tt>:support_ewkb</tt>]
+    #   Activate support for PostGIS EWKB type codes, which use high
+    #   order bits in the type code to signal the presence of Z, M, and
+    #   SRID values in the data. Default is false.
+    # [<tt>:support_wkb12</tt>]
+    #   Activate support for SFS 1.2 extensions to the type codes, which
+    #   use values greater than 1000 to signal the presence of Z and M
+    #   values in the data. SFS 1.2 types such as triangle, tin, and
+    #   polyhedralsurface are NOT yet supported. Default is false.
+    # [<tt>:ignore_extra_bytes</tt>]
+    #   If true, extra bytes at the end of the data are ignored. If
+    #   false (the default), extra bytes will trigger a parse error.
+    # [<tt>:default_srid</tt>]
+    #   A SRID to pass to the factory generator if no SRID is present in
+    #   the input. Defaults to nil (i.e. don't specify a SRID).
+
+    class WKBParser
+      # Create and configure a WKB parser. See the WKBParser
+      # documentation for the options that can be passed.
+
+      def initialize(factory_generator_ = nil, opts_ = {})
+        if factory_generator_.is_a?(Feature::Factory::Instance)
+          @factory_generator = Feature::FactoryGenerator.single(factory_generator_)
+          @exact_factory = factory_generator_
+        elsif factory_generator_.respond_to?(:call)
+          @factory_generator = factory_generator_
+          @exact_factory = nil
+        else
+          @factory_generator = Cartesian.method(:preferred_factory)
+          @exact_factory = nil
+        end
+        @support_ewkb = opts_[:support_ewkb] ? true : false
+        @support_wkb12 = opts_[:support_wkb12] ? true : false
+        @ignore_extra_bytes = opts_[:ignore_extra_bytes] ? true : false
+        @default_srid = opts_[:default_srid]
+      end
+
+      # Returns the factory generator. See WKBParser for details.
+      attr_reader :factory_generator
+
+      # If this parser was given an exact factory, returns it; otherwise
+      # returns nil.
+      attr_reader :exact_factory
+
+      # Returns true if this parser supports EWKB.
+      # See WKBParser for details.
+      def support_ewkb?
+        @support_ewkb
+      end
+
+      # Returns true if this parser supports SFS 1.2 extensions.
+      # See WKBParser for details.
+      def support_wkb12?
+        @support_wkb12
+      end
+
+      # Returns true if this parser ignores extra bytes.
+      # See WKBParser for details.
+      def ignore_extra_bytes?
+        @ignore_extra_bytes
+      end
+
+      def _properties # :nodoc:
+        {
+          "support_ewkb" => @support_ewkb,
+          "support_wkb12" => @support_wkb12,
+          "ignore_extra_bytes" => @ignore_extra_bytes,
+          "default_srid" => @default_srid
+        }
+      end
+
+      # Parse the given binary data or hexadecimal string, and return a
+      # geometry object.
+      #
+      # The #parse_hex method is a synonym, present for historical
+      # reasons but deprecated. Use #parse instead.
+
+      def parse(data_)
+        data_ = [data_].pack("H*") if data_[0, 1] =~ /[0-9a-fA-F]/
+        @cur_has_z = nil
+        @cur_has_m = nil
+        @cur_srid = nil
+        @cur_dims = 2
+        @cur_factory = nil
+        begin
+          _start_scanner(data_)
+          obj_ = _parse_object(false)
+          unless @ignore_extra_bytes
+            bytes_ = _bytes_remaining
+            if bytes_ > 0
+              raise Error::ParseError, "Found #{bytes_} extra bytes at the end of the stream."
+            end
+          end
+        ensure
+          _clean_scanner
+        end
+        obj_
+      end
+      alias_method :parse_hex, :parse
+
+      def _parse_object(contained_) # :nodoc:
+        endian_value_ = _get_byte
+        case endian_value_
+        when 0
+          little_endian_ = false
+        when 1
+          little_endian_ = true
+        else
+          raise Error::ParseError, "Bad endian byte value: #{endian_value_}"
+        end
+        type_code_ = _get_integer(little_endian_)
+        has_z_ = false
+        has_m_ = false
+        srid_ = contained_ ? nil : @default_srid
+        if @support_ewkb
+          has_z_ ||= type_code_ & 0x80000000 != 0
+          has_m_ ||= type_code_ & 0x40000000 != 0
+          srid_ = _get_integer(little_endian_) if type_code_ & 0x20000000 != 0
+          type_code_ &= 0x0fffffff
+        end
+        if @support_wkb12
+          has_z_ ||= (type_code_ / 1000) & 1 != 0
+          has_m_ ||= (type_code_ / 1000) & 2 != 0
+          type_code_ %= 1000
+        end
+        if contained_
+          if contained_ != true && contained_ != type_code_
+            raise Error::ParseError, "Enclosed type=#{type_code_} is different from container constraint #{contained_}"
+          end
+          if has_z_ != @cur_has_z
+            raise Error::ParseError, "Enclosed hasZ=#{has_z_} is different from toplevel hasZ=#{@cur_has_z}"
+          end
+          if has_m_ != @cur_has_m
+            raise Error::ParseError, "Enclosed hasM=#{has_m_} is different from toplevel hasM=#{@cur_has_m}"
+          end
+          if srid_ && srid_ != @cur_srid
+            raise Error::ParseError, "Enclosed SRID #{srid_} is different from toplevel srid #{@cur_srid || '(unspecified)'}"
+          end
+        else
+          @cur_has_z = has_z_
+          @cur_has_m = has_m_
+          @cur_dims = 2 + (@cur_has_z ? 1 : 0) + (@cur_has_m ? 1 : 0)
+          @cur_srid = srid_
+          @cur_factory = @factory_generator.call(srid: @cur_srid, has_z_coordinate: has_z_, has_m_coordinate: has_m_)
+          if @cur_has_z && !@cur_factory.property(:has_z_coordinate)
+            raise Error::ParseError, "Data has Z coordinates but the factory doesn't have Z coordinates"
+          end
+          if @cur_has_m && !@cur_factory.property(:has_m_coordinate)
+            raise Error::ParseError, "Data has M coordinates but the factory doesn't have M coordinates"
+          end
+        end
+        case type_code_
+        when 1
+          coords_ = _get_doubles(little_endian_, @cur_dims)
+          @cur_factory.point(*coords_)
+        when 2
+          _parse_line_string(little_endian_)
+        when 3
+          interior_rings_ = (1.._get_integer(little_endian_)).map { _parse_line_string(little_endian_) }
+          exterior_ring_ = interior_rings_.shift || @cur_factory.linear_ring([])
+          @cur_factory.polygon(exterior_ring_, interior_rings_)
+        when 4
+          @cur_factory.multi_point((1.._get_integer(little_endian_)).map { _parse_object(1) })
+        when 5
+          @cur_factory.multi_line_string((1.._get_integer(little_endian_)).map { _parse_object(2) })
+        when 6
+          @cur_factory.multi_polygon((1.._get_integer(little_endian_)).map { _parse_object(3) })
+        when 7
+          @cur_factory.collection((1.._get_integer(little_endian_)).map { _parse_object(true) })
+        else
+          raise Error::ParseError, "Unknown type value: #{type_code_}."
+        end
+      end
+
+      def _parse_line_string(little_endian_) # :nodoc:
+        count_ = _get_integer(little_endian_)
+        coords_ = _get_doubles(little_endian_, @cur_dims * count_)
+        @cur_factory.line_string((0...count_).map { |i_| @cur_factory.point(*coords_[@cur_dims * i_, @cur_dims]) })
+      end
+
+      def _start_scanner(data_) # :nodoc:
+        @_data = data_
+        @_len = data_.length
+        @_pos = 0
+      end
+
+      def _clean_scanner # :nodoc:
+        @_data = nil
+      end
+
+      def _bytes_remaining # :nodoc:
+        @_len - @_pos
+      end
+
+      def _get_byte # :nodoc:
+        if @_pos + 1 > @_len
+          raise Error::ParseError, "Not enough bytes left to fulfill 1 byte"
+        end
+        str_ = @_data[@_pos, 1]
+        @_pos += 1
+        str_.unpack("C").first
+      end
+
+      def _get_integer(little_endian_) # :nodoc:
+        if @_pos + 4 > @_len
+          raise Error::ParseError, "Not enough bytes left to fulfill 1 integer"
+        end
+        str_ = @_data[@_pos, 4]
+        @_pos += 4
+        str_.unpack("#{little_endian_ ? 'V' : 'N'}").first
+      end
+
+      def _get_doubles(little_endian_, count_) # :nodoc:
+        len_ = 8 * count_
+        if @_pos + len_ > @_len
+          raise Error::ParseError, "Not enough bytes left to fulfill #{count_} doubles"
+        end
+        str_ = @_data[@_pos, len_]
+        @_pos += len_
+        str_.unpack("#{little_endian_ ? 'E' : 'G'}*")
+      end
+    end
+  end
+end