geekdaily-georuby 2.6.0

data/lib/geo_ruby/simple_features.rb

@@ -0,0 +1,21 @@
+module GeoRuby
+  module SimpleFeatures
+    %w(
+      geometry
+      circle
+      envelope
+      geometry_collection
+      geometry_factory
+      helper
+      line_string
+      linear_ring
+      multi_line_string
+      multi_point
+      multi_polygon
+      point
+      polygon
+    ).each do |rel_file|
+      require File.join(File.dirname(__FILE__), 'simple_features', rel_file)
+    end
+  end
+end

data/lib/geo_ruby/simple_features/circle.rb

@@ -0,0 +1,59 @@
+module GeoRuby
+  module SimpleFeatures
+    # Represents a point. It is in 3D if the Z coordinate is not +nil+.
+    class Circle < Geometry
+      attr_accessor :radius, :center
+      alias_method :r, :radius
+      alias_method :c, :center
+
+      def initialize(srid = DEFAULT_SRID, with_z = false, with_m = false)
+        super(srid, with_z, with_m)
+      end
+
+      def bounding_box
+        [Point.from_x_y(@center.x - @r, @center.y - @r),
+         Point.from_x_y(@center.x + @r, @center.y + @r)]
+      end
+
+      def diameter
+        radius * 2
+      end
+
+      def m_range
+        fail NotImplementedError
+      end
+
+      def ==(other)
+        return false unless other.is_a?(Circle)
+        @center == other.center && @radius == other.radius
+      end
+
+      def to_json(options = {})
+        { type: 'Circle',
+          coordinates: @center.to_coordinates,
+          radius: @radius }.to_json(options)
+      end
+      alias_method :as_geojson, :to_json
+
+      def contains_point?(point)
+        @center.euclidian_distance(point) <= radius
+      end
+
+      class << self
+        def from_x_y_r(x, y, r, srid = DEFAULT_SRID)
+          circle = new(srid)
+          circle.center = Point.from_x_y(x, y, srid)
+          circle.radius = r
+          circle
+        end
+
+        def from_coordinates(center, r, srid = DEFAULT_SRID)
+          circle = new(srid)
+          circle.center = Point.from_coordinates(center)
+          circle.radius = r
+          circle
+        end
+      end
+    end
+  end
+end

data/lib/geo_ruby/simple_features/envelope.rb

@@ -0,0 +1,174 @@
+module GeoRuby
+  module SimpleFeatures
+    # Contains the bounding box of a geometry
+    class Envelope
+      attr_accessor :lower_corner, :upper_corner
+      attr_accessor :srid, :with_z, :zoom
+
+      # Creates a enw Envelope with +lower_corner+ as the first element
+      # of the corners array and +upper_corner+ as the second element
+      def initialize(srid = DEFAULT_SRID, with_z = false)
+        @srid = srid
+        @with_z = with_z
+      end
+
+      # Merges the argument with the current evelope
+      def extend!(envelope)
+        lower_corner.x = [lower_corner.x, envelope.lower_corner.x].min
+        lower_corner.y = [lower_corner.y, envelope.lower_corner.y].min
+        upper_corner.x = [upper_corner.x, envelope.upper_corner.x].max
+        upper_corner.y = [upper_corner.y, envelope.upper_corner.y].max
+        self
+      end
+
+      # Merges the argument with the current evelope and sends back a new
+      # envelope without changing the current one
+      def extend(envelope)
+        e = Envelope.from_points([Point.from_x_y(lower_corner.x, lower_corner.y),
+                                  Point.from_x_y(upper_corner.x, upper_corner.y)], srid, with_z)
+        e.extend!(envelope)
+        e
+      end
+
+      #  def bounding_box(markers)
+      #    max_lat, max_lon, min_lat, min_lon = -Float::MAX, -Float::MAX, Float::MAX, Float::MAX
+      #    markers.each do |marker|
+      #      coord = marker.point
+      #      max_lat = coord.lat if coord.lat > max_lat
+      #      min_lat = coord.lat if coord.lat < min_lat
+      #      max_lon = coord.lng if coord.lng > max_lon
+      #      min_lon = coord.lng if coord.lng < min_lon
+      #    end
+      #    min_point = Point.from_x_y(min_lat,min_lon)
+      #    max_point = Point.from_x_y(max_lat,max_lon)
+
+      #    end
+      #    centrelat = (max_lat + min_lat)/2
+      #    centrelng = (max_lon + min_lon)/2
+      #    # logger.info("distance[#{distance}],zoom[#{zoom}]")
+      #    #return GLatLngBounds.new(GLatLng.new(min_point),GLatLng.new(max_point)), [centrelat,centrelng], zoom
+      #    return [centrelat,centrelng], zoom
+
+      # Sends back the center of the envelope
+      def center
+        Point.from_x_y((lower_corner.x + upper_corner.x) / 2, (lower_corner.y + upper_corner.y) / 2, srid)
+      end
+
+      # Zoom level
+      def zoom
+        distance = lower_corner.spherical_distance(upper_corner) / 10_000
+        @zoom = case distance
+                when 150..9000  then 5
+                when 80..149    then 6
+                when 50..79     then 7
+                when 20..49     then 8
+                when 10..19     then 9
+                when 5..9       then 10
+                else 13
+                end
+      end
+
+      # Tests the equality of line strings
+      def ==(other_envelope)
+        if other_envelope.class != self.class
+          false
+        else
+          upper_corner == other_envelope.upper_corner && lower_corner == other_envelope.lower_corner
+        end
+      end
+
+      # georss serialization: Dialect can be passed as option <tt>:dialect</tt>
+      # and set to <tt>:simple</tt> (default) <tt>:w3cgeo</tt> or <tt>:gml</tt>.
+      # Options <tt>:featuretypetag
+      def as_georss(options = {})
+        dialect = options[:dialect] || :simple
+        case (dialect)
+        when :simple
+          geom_attr = ''
+          if options[:featuretypetag]
+            geom_attr += " featuretypetag=\"#{options[:featuretypetag]}\""
+          end
+          if options[:relationshiptag]
+            geom_attr += " relationshiptag=\"#{options[:relationshiptag]}\""
+          end
+          geom_attr += " floor=\"#{options[:floor]}\"" if options[:floor]
+          geom_attr += " radius=\"#{options[:radius]}\"" if options[:radius]
+          geom_attr += " elev=\"#{options[:elev]}\"" if options[:elev]
+
+          georss_simple_representation(options.merge(geom_attr: geom_attr))
+        when :w3cgeo
+          georss_w3cgeo_representation(options)
+        when :gml
+          georss_gml_representation(options)
+        end
+      end
+
+      # georss simple representation
+      def georss_simple_representation(options = {}) #:nodoc:
+        georss_ns = options[:georss_ns] || 'georss'
+        geom_attr = options[:geom_attr]
+        "<#{georss_ns}:box#{geom_attr}>#{lower_corner.y} #{lower_corner.x} #{upper_corner.y} #{upper_corner.x}</#{georss_ns}:box>\n"
+      end
+
+      # georss w3c representation : outputs the first point of the line
+      def georss_w3cgeo_representation(options = {}) #:nodoc:
+        w3cgeo_ns = options[:w3cgeo_ns] || 'geo'
+        point = center
+        "<#{w3cgeo_ns}:lat>#{point.y}</#{w3cgeo_ns}:lat>\n<#{w3cgeo_ns}:long>#{point.x}</#{w3cgeo_ns}:long>\n"
+      end
+
+      # georss gml representation
+      def georss_gml_representation(options = {}) #:nodoc:
+        georss_ns = options[:georss_ns] || 'georss'
+        gml_ns = options[:gml_ns] || 'gml'
+        result = "<#{georss_ns}:where>\n<#{gml_ns}:Envelope>\n"
+        result += "<#{gml_ns}:LowerCorner>#{lower_corner.y} #{lower_corner.x}"\
+                  "</#{gml_ns}:LowerCorner>"
+        result += "<#{gml_ns}:UpperCorner>#{upper_corner.y} #{upper_corner.x}"\
+                  "</#{gml_ns}:UpperCorner>"
+        result + "</#{gml_ns}:Envelope>\n</#{georss_ns}:where>\n"
+      end
+
+      # Sends back a latlonaltbox
+      def as_kml(options = {})
+        geom_data = ''
+        geom_data = "<altitudeMode>#{options[:altitude_mode]}</altitudeMode>\n" if options[:altitude_mode]
+
+        allow_z = with_z && (!options[:altitude_mode].nil?) && options[:atitude_mode] != 'clampToGround'
+
+        kml_representation(options.merge(geom_data: geom_data, allow_z: allow_z))
+      end
+
+      def kml_representation(options = {}) #:nodoc:
+        result = "<LatLonAltBox>\n"
+        result += options[:geom_data]
+        result += "<north>#{upper_corner.y}</north>\n"
+        result += "<south>#{lower_corner.y}</south>\n"
+        result += "<east>#{upper_corner.x}</east>\n"
+        result += "<west>#{lower_corner.x}</west>\n"
+
+        if with_z
+          result += "<minAltitude>#{lower_corner.z}</minAltitude>"
+          result += "<maxAltitude>#{upper_corner.z}</maxAltitude>"
+        end
+
+        result + "</LatLonAltBox>\n"
+      end
+
+      # Creates a new envelope. Accept an array of 2 points as argument
+      def self.from_points(points, srid = DEFAULT_SRID, with_z = false)
+        fail 'Not an array' unless points.class == Array
+        e = Envelope.new(srid, with_z)
+        e.lower_corner, e.upper_corner = points
+        e
+      end
+
+      # Creates a new envelope. Accept a sequence of point coordinates as argument : ((x,y),(x,y))
+      def self.from_coordinates(points, srid = DEFAULT_SRID, with_z = false)
+        e = Envelope.new(srid, with_z)
+        e.lower_corner, e.upper_corner =  points.collect { |point_coords| Point.from_coordinates(point_coords, srid, with_z) }
+        e
+      end
+    end
+  end
+end

data/lib/geo_ruby/simple_features/geometry.rb

@@ -0,0 +1,252 @@
+module GeoRuby #:nodoc:
+  module SimpleFeatures
+    # TODO: Should this move to simple_features.rb instead?
+    # Default SRID is WGS84, see https://en.wikipedia.org/wiki/Spatial_reference_system
+    DEFAULT_SRID = 4326 unless defined? DEFAULT_SRID
+
+    # Root of all geometric data classes.
+    # Objects of class Geometry should not be instantiated.
+    class Geometry
+      # SRID of the geometry
+      attr_reader :srid # writer defined below
+      # Flag indicating if the z ordinate of the geometry is meaningful
+      attr_accessor :with_z
+      alias_method :with_z?, :with_z
+      # Flag indicating if the m ordinate of the geometry is meaningful
+      attr_accessor :with_m
+      alias_method :with_m?, :with_m
+
+      def initialize(srid = DEFAULT_SRID, with_z = false, with_m = false)
+        @srid = srid
+        @with_z = with_z
+        @with_m = with_m
+      end
+
+      def srid=(new_srid)
+        @srid = new_srid
+        unless self.is_a?(Point)
+          each do |geom|
+            geom.srid = new_srid
+          end
+        end
+      end
+
+      # to be implemented in subclasses
+      def bounding_box
+      end
+
+      # to be implemented in subclasses
+      def m_range
+      end
+
+      #
+      # Returns an Envelope object for the geometry
+      #
+      def envelope
+        Envelope.from_points(bounding_box, srid, with_z)
+      end
+
+      #
+      # Outputs the geometry as an EWKB string.
+      #
+      # The +allow_srid+, +allow_z+ and +allow_m+ arguments allow the output
+      # to include srid, z and m respectively if they are present.
+      # If these arguments are set to false, srid, z and m are not included,
+      # even if they are present in the geometry.
+      # By default, the output string contains all the information in the object.
+      #
+      def as_ewkb(allow_srid = true, allow_z = true, allow_m = true)
+        ewkb = 1.chr # little_endian by default
+
+        type = binary_geometry_type
+        type |= Z_MASK if @with_z && allow_z
+        type |= M_MASK if @with_m && allow_m
+
+        if allow_srid
+          type = type | SRID_MASK
+          ewkb << [type, @srid].pack('VV')
+        else
+          ewkb << [type].pack('V')
+        end
+
+        ewkb  << binary_representation(allow_z, allow_m)
+      end
+
+      #
+      # Outputs the geometry as a strict WKB string.
+      #
+      def as_wkb
+        as_ewkb(false, false, false)
+      end
+
+      #
+      # Outputs the geometry as a HexEWKB string.
+      # It is almost the same as a WKB string, except that each byte of a WKB
+      # string is replaced by its hex 2-char representation in a HexEWKB string.
+      #
+      def as_hex_ewkb(allow_srid = true, allow_z = true, allow_m = true)
+        as_ewkb(allow_srid, allow_z, allow_m).unpack('H*').join('').upcase
+      end
+
+      #
+      # Outputs the geometry as a strict HexWKB string
+      #
+      def as_hex_wkb
+        as_hex_ewkb(false, false, false)
+      end
+
+      #
+      # Outputs the geometry as an EWKT string.
+      #
+      def as_ewkt(allow_srid = true, allow_z = true, allow_m = true)
+        if allow_srid
+          ewkt = "SRID=#{@srid};"
+        else
+          ewkt = ''
+        end
+        ewkt << text_geometry_type
+        # to distinguish the M from the Z when there is actually no Z...
+        ewkt << 'M' if @with_m && allow_m && (!@with_z || !allow_z)
+        ewkt << '(' << text_representation(allow_z, allow_m) << ')'
+      end
+
+      #
+      # Outputs the geometry as strict WKT string.
+      #
+      def as_wkt
+        as_ewkt(false, false, false)
+      end
+
+      # Outputs the geometry in georss format.
+      # Assumes the geometries are in latlon format, with x as lon and y as lat.
+      # Pass the <tt>:dialect</tt> option to swhit format. Possible values are:
+      # <tt>:simple</tt> (default), <tt>:w3cgeo</tt> and <tt>:gml</tt>.
+      def as_georss(options = {})
+        dialect = options[:dialect] || :simple
+        case (dialect)
+        when :simple
+          geom_attr = ''
+          if options[:featuretypetag]
+            geom_attr += " featuretypetag=\"#{options[:featuretypetag]}\""
+          end
+          if options[:relationshiptag]
+            geom_attr += " relationshiptag=\"#{options[:relationshiptag]}\""
+          end
+          geom_attr += " floor=\"#{options[:floor]}\"" if options[:floor]
+          geom_attr += " radius=\"#{options[:radius]}\"" if options[:radius]
+          geom_attr += " elev=\"#{options[:elev]}\"" if options[:elev]
+          georss_simple_representation(options.merge(geom_attr: geom_attr))
+        when :w3cgeo
+          georss_w3cgeo_representation(options)
+        when :gml
+          georss_gml_representation(options)
+        end
+      end
+
+      # Iutputs the geometry in kml format : options are <tt>:id</tt>,
+      # <tt>:tesselate</tt>, <tt>:extrude</tt>, <tt>:altitude_mode</tt>.
+      # If the altitude_mode option is not present, the Z (if present) will not
+      # be output (since it won't be used by GE: clampToGround is the default)
+      def as_kml(options = {})
+        id_attr = ''
+        id_attr = " id=\"#{options[:id]}\"" if options[:id]
+
+        geom_data = ''
+        if options[:extrude]
+          geom_data += "<extrude>#{options[:extrude]}</extrude>\n"
+        end
+        if options[:tesselate]
+          geom_data += "<tesselate>#{options[:tesselate]}</tesselate>\n"
+        end
+        if options[:altitude_mode]
+          geom_data += "<altitudeMode>#{options[:altitude_mode]}</altitudeMode>\n"
+        end
+
+        allow_z = (with_z || !options[:altitude].nil?) &&
+                  (!options[:altitude_mode].nil?) &&
+                  options[:atitude_mode] != 'clampToGround'
+        fixed_z = options[:altitude]
+
+        kml_representation(options.merge(id_attr: id_attr, geom_data: geom_data,
+                                         allow_z: allow_z, fixed_z: fixed_z))
+      end
+
+      # simple geojson representation
+      # TODO add CRS / SRID support?
+      def to_json(options = {})
+        as_json(options).to_json(options)
+      end
+
+      def as_json(_options = {})
+        # Implemented by each class
+      end
+      alias_method :as_geojson, :as_json
+
+      # Creates a geometry based on a EWKB string. The actual class returned
+      # depends of the content of the string passed as argument.
+      # Since WKB strings are a subset of EWKB, they are also valid.
+      def self.from_ewkb(ewkb)
+        factory = GeometryFactory.new
+        ewkb_parser = EWKBParser.new(factory)
+        ewkb_parser.parse(ewkb)
+        factory.geometry
+      end
+
+      # Creates a geometry based on a HexEWKB string given.
+      def self.from_hex_ewkb(hexewkb)
+        factory = GeometryFactory.new
+        hexewkb_parser = HexEWKBParser.new(factory)
+        hexewkb_parser.parse(hexewkb)
+        factory.geometry
+      end
+
+      # Creates a geometry based on a EWKT string. Since WKT strings are a
+      # subset of EWKT, they are also valid.
+      def self.from_ewkt(ewkt)
+        factory = GeometryFactory.new
+        ewkt_parser = EWKTParser.new(factory)
+        ewkt_parser.parse(ewkt)
+        factory.geometry
+      end
+
+      # Creates a geometry based on the GeoRSS string given.
+      def self.from_georss(georss)
+        georss_parser = GeorssParser.new
+        georss_parser.parse(georss)
+        georss_parser.geometry
+      end
+
+      # sends back an array: The first element is the goemetry based on the
+      # GeoRSS string passed as argument. The second one is the GeoRSSTags
+      # (found only with the Simple format)
+      def self.from_georss_with_tags(georss)
+        georss_parser = GeorssParser.new
+        georss_parser.parse(georss, true)
+        [georss_parser.geometry, georss_parser.georss_tags]
+      end
+
+      # Sends back a geometry from a KML encoded geometry string.
+      def self.from_kml(kml)
+        factory = GeometryFactory.new
+        parser = KmlParser.new(factory)
+        parser.parse(kml)
+      end
+
+      # Some GeoJSON files do not include srid info, so
+      # we provide an optional parameter
+      def self.from_geojson(geojson, srid = DEFAULT_SRID)
+        geojson_parser = GeoJSONParser.new
+        geojson_parser.parse(geojson, srid)
+        geojson_parser.geometry
+      end
+
+      private
+
+      def self.split_coords(coords)
+        coords.split(' ').collect do |coord|
+          coord.gsub(',', ' ')
+        end
+      end
+    end
+  end
+end