charta 0.1.0

data/lib/charta/geojson_import.rb

@@ -0,0 +1,30 @@
+require 'nokogiri'
+
+class GeojsonImport
+  # TODO: handle a File object instead of calling IO read/write directly
+  def initialize(data)
+    @shapes = nil
+    @xml = data
+  end
+
+  def valid?
+    shapes = JSON.parse(@xml)
+    ::Charta::GeoJSON.valid?(shapes)
+  end
+
+  def shapes(options = {})
+    options[:to] ||= :json
+
+    @shapes = JSON.parse(@xml)
+
+    if options[:to].equal? :json
+      @shapes = @shapes.to_json
+    elsif options[:to].equal? :string
+      @shapes = @shapes.to_s
+    end
+  end
+
+  def as_geojson
+    @shapes.to_json
+  end
+end

data/lib/charta/geometry.rb

@@ -0,0 +1,278 @@
+require 'json'
+require 'rgeo/geo_json'
+require 'rgeo/svg' # integrated lib for now
+
+module Charta
+  # Represents a Geometry with SRID
+  class Geometry
+    def initialize(ewkt)
+      @ewkt = ewkt
+      raise ArgumentError, 'Need EWKT to instantiate Geometry' if @ewkt.to_s =~ /\A[[:space:]]*\z/
+    end
+
+    def inspect
+      "<#{self.class.name}(#{to_ewkt})>"
+    end
+
+    # Returns the type of the geometry as a string. Example: point,
+    # multi_polygon, geometry_collection...
+    def type
+      Charta.underscore(feature.geometry_type.type_name).to_sym
+    end
+
+    # Returns the type of the geometry as a string. EG: 'ST_Linestring', 'ST_Polygon',
+    # 'ST_MultiPolygon' etc. This function differs from GeometryType(geometry)
+    # in the case of the string and ST in front that is returned, as well as the fact
+    # that it will not indicate whether the geometry is measured.
+    def collection?
+      feature.geometry_type == RGeo::Feature::GeometryCollection
+    end
+
+    # Return the spatial reference identifier for the ST_Geometry
+    def srid
+      feature.srid.to_i
+    end
+
+    # Returns the underlaying object managed by Charta: the RGeo feature
+    def to_rgeo
+      feature
+    end
+
+    # Returns the Well-Known Text (WKT) representation of the geometry/geography without SRID metadata
+    def to_text
+      feature.as_text
+    end
+    alias as_text to_text
+    alias to_wkt to_text
+
+    # Returns EWKT: WKT with its SRID
+    def to_ewkt
+      @ewkt.to_s
+    end
+    alias to_s to_ewkt
+
+    def ewkt
+      puts 'DEPRECATION WARNING: Charta::Geometry.ewkt is deprecated. Please use Charta::Geometry.to_ewkt instead'
+      to_ewkt
+    end
+
+    #  Return the Well-Known Binary (WKB) representation of the geometry with SRID meta data.
+    def to_binary
+      generator = RGeo::WKRep::WKBGenerator.new(tag_format: :ewkbt, emit_ewkbt_srid: true)
+      generator.generate(feature)
+    end
+    alias to_ewkb to_binary
+
+    # Pas bien compris le fonctionnement
+    def to_svg(options = {})
+      svg = '<svg xmlns="http://www.w3.org/2000/svg" version="1.1"'
+      { preserve_aspect_ratio: 'xMidYMid meet',
+        width: 180, height: 180,
+        view_box: bounding_box.svg_view_box.join(' ') }.merge(options).each do |attr, value|
+        svg << " #{Charta.camelcase(attr.to_s, :lower)}=\"#{value}\""
+      end
+      svg << "><path d=\"#{to_svg_path}\"/></svg>"
+      svg
+    end
+
+    # Return the geometry as Scalar Vector Graphics (SVG) path data.
+    def to_svg_path
+      RGeo::SVG.encode(feature)
+    end
+
+    # Return the geometry as a Geometry Javascript Object Notation (GeoJSON) element.
+    def to_geojson
+      to_json_object.to_json
+    end
+    alias to_json to_geojson
+
+    # Returns object in JSON (Hash)
+    def to_json_object
+      RGeo::GeoJSON.encode(feature)
+    end
+
+    # Test if the other measure is equal to self
+    def ==(other)
+      other_geometry = Charta.new_geometry(other).transform(srid)
+      return true if empty? && other_geometry.empty?
+      return inspect == other_geometry.inspect if collection? && other_geometry.collection?
+      feature.equals?(other_geometry.feature)
+    end
+
+    # Test if the other measure is equal to self
+    def !=(other)
+      other_geometry = Charta.new_geometry(other).transform(srid)
+      return true if empty? && other_geometry.empty?
+      return inspect == other_geometry.inspect if collection? && other_geometry.collection?
+      !feature.equals?(other_geometry.feature)
+    end
+
+    # Returns true if Geometry is a Surface
+    def surface?
+      [RGeo::Feature::Polygon, RGeo::Feature::MultiPolygon].include? feature.geometry_type
+    end
+
+    # Returns area in unit corresponding to the SRS
+    def area
+      surface? ? feature.area : 0
+    end
+
+    # Returns true if this Geometry is an empty geometrycollection, polygon,
+    # point etc.
+    def empty?
+      feature.is_empty?
+    end
+    alias blank? empty?
+
+    # Computes the geometric center of a geometry, or equivalently, the center
+    # of mass of the geometry as a POINT.
+    def centroid
+      surface? ? feature.centroid : nil
+    end
+
+    # Returns a POINT guaranteed to lie on the surface.
+    def point_on_surface
+      surface? ? feature.point_on_surface : nil
+    end
+
+    def convert_to(new_type)
+      if new_type == type
+        self
+      elsif new_type == :multi_point
+        flatten_multi(:point)
+      elsif new_type == :multi_line_string
+        flatten_multi(:line_string)
+      elsif new_type == :multi_polygon
+        flatten_multi(:polygon)
+      end
+    end
+
+    def flatten_multi(as_type)
+      items = []
+      as_multi_type = "multi_#{as_type}".to_sym
+      if type == as_type
+        items << feature
+      elsif is_a? :geometry_collection
+        feature.each do |geom|
+          type_name = Charta.underscore(geom.geometry_type.type_name).to_sym
+          if type_name == as_type
+            items << geom
+          elsif type_name == as_multi_type
+            geom.each do |item|
+              items << item
+            end
+          end
+        end
+      end
+      Charta.new_geometry(feature.factory.send(as_multi_type, items))
+    end
+
+    # Returns a new geometry with the coordinates converted into the new SRS
+    def transform(new_srid)
+      return self if new_srid == srid
+      raise 'Proj is not supported. Cannot tranform' unless RGeo::CoordSys::Proj4.supported?
+      new_srid = Charta::SRS[new_srid] || new_srid
+      database = self.class.srs_database
+      new_proj_entry = database.get(new_srid)
+      raise "Cannot find proj for SRID: #{new_srid}" if new_proj_entry.nil?
+      new_feature = RGeo::CoordSys::Proj4.transform(
+        database.get(srid).proj4,
+        feature,
+        new_proj_entry.proj4,
+        self.class.factory(new_srid)
+      )
+      generator = RGeo::WKRep::WKTGenerator.new(tag_format: :ewkt, emit_ewkt_srid: true)
+      self.class.new(generator.generate(new_feature))
+    end
+
+    # Produces buffer
+    def buffer(radius)
+      feature.buffer(radius)
+    end
+
+    def merge(other)
+      other_geometry = Charta.new_geometry(other).transform(srid)
+      feature.union(other_geometry.feature)
+    end
+    alias + merge
+
+    def intersection(other)
+      other_geometry = Charta.new_geometry(other).transform(srid)
+      feature.intersection(other_geometry.feature)
+    end
+
+    def difference(other)
+      other_geometry = Charta.new_geometry(other).transform(srid)
+      feature.difference(other_geometry.feature)
+    end
+    alias - difference
+
+    def bounding_box
+      unless defined? @bounding_box
+        bbox = RGeo::Cartesian::BoundingBox.create_from_geometry(feature)
+        instance_variable_set('@x_min', bbox.min_x || 0)
+        instance_variable_set('@y_min', bbox.min_y || 0)
+        instance_variable_set('@x_max', bbox.max_x || 0)
+        instance_variable_set('@y_max', bbox.max_y || 0)
+        @bounding_box = BoundingBox.new(@y_min, @x_min, @y_max, @x_max)
+      end
+      @bounding_box
+    end
+
+    %i[x_min y_min x_max y_max].each do |name|
+      define_method name do
+        bounding_box.send(name)
+      end
+    end
+
+    def find_srid(name_or_srid)
+      Charta.find_srid(name_or_srid)
+    end
+
+    def feature
+      self.class.feature(@ewkt)
+    end
+
+    class << self
+      def srs_database
+        @srs_database ||= RGeo::CoordSys::SRSDatabase::Proj4Data.new('epsg', authority: 'EPSG', cache: true)
+      end
+
+      def factory(srid = 4326)
+        RGeo::Geos.factory(
+          # srs_database: srs_database,
+          srid: srid,
+          # has_z_coordinate: true,
+          wkt_generator: {
+            type_format: :ewkt,
+            emit_ewkt_srid: true,
+            convert_case: :upper
+          },
+          wkt_parser: {
+            support_ewkt: true
+          },
+          wkb_generator:  {
+            type_format: :ewkb,
+            emit_ewkb_srid: true,
+            hex_format: true
+          },
+          wkb_parser: {
+            support_ewkb: true
+          }
+        )
+      end
+
+      def feature(ewkt)
+        # Cleans empty geometries
+        ewkt.gsub!(/(GEOMETRYCOLLECTION|GEOMETRY|((MULTI)?(POINT|LINESTRING|POLYGON)))\(\)/, '\1 EMPTY')
+        srs = ewkt.split(/[\=\;]+/)[0..1]
+        srid = nil
+        srid = srs[1] if srs[0] =~ /srid/i
+        srid ||= 4326
+        factory(srid).parse_wkt(ewkt)
+      rescue RGeo::Error::ParseError => e
+        raise "Invalid EWKT (#{e.class.name}: #{e.message}): #{ewkt}"
+      end
+    end
+  end
+end

data/lib/charta/geometry_collection.rb

@@ -0,0 +1,9 @@
+module Charta
+  # Represent a Geometry with contains other geometries
+  class GeometryCollection < Geometry
+    def self.empty(srid = nil)
+      srid = Charta.find_srid(srid.nil? ? :WGS84 : srid)
+      new("SRID=#{srid};GEOMETRYCOLLECTION EMPTY")
+    end
+  end
+end

data/lib/charta/gml.rb

@@ -0,0 +1,140 @@
+require 'nokogiri'
+
+module Charta
+  # Represents a Geometry with SRID
+  class GML
+    attr_reader :srid
+
+    TAGS = %w[Point LineString Polygon MultiGeometry].freeze
+    OGR_PREFIX = 'ogr'.freeze
+    GML_PREFIX = 'gml'.freeze
+    NS = {
+      gml: 'http://www.opengis.net/gml',
+      ogr: 'http://ogr.maptools.org/'
+    }.freeze
+
+    def initialize(data, srid = :WGS84)
+      srid ||= :WGS84
+      @gml = if data.is_a? String
+
+               Nokogiri::XML(data.to_s.split.join(' ')) do |config|
+                 config.options = Nokogiri::XML::ParseOptions::NOBLANKS
+               end
+
+             else
+               # Nokogiri::XML::Document expected
+               data
+             end
+      up = false
+      # ensure namespaces are defined
+      begin
+        @gml.root.add_namespace_definition('xmlns', '')
+        NS.each do |k, v|
+          if @gml.xpath("//@*[xmlns:#{k}]").empty?
+            @gml.root.namespace_definitions << @gml.root.add_namespace_definition(k.to_s, v)
+            up = true
+          end
+        end
+      rescue
+        false
+      end
+
+      @gml = Nokogiri::XML(@gml.to_xml) if up
+
+      boundaries = @gml.css("#{GML_PREFIX}|boundedBy")
+      unless boundaries.nil?
+        boundaries.each do |node|
+          srid = Charta.find_srid(node['srsName']) unless node['srsName'].nil?
+        end
+      end
+
+      @srid = Charta.find_srid(srid)
+    end
+
+    def to_ewkt
+      "SRID=#{@srid};" + self.class.document_to_ewkt(@gml, @srid)
+    end
+
+    def valid?
+      to_ewkt
+      true
+    end
+
+    class << self
+      # Test is given data is a valid GML
+      def valid?(data, srid = :WGS84)
+        new(data, srid).valid?
+      end
+
+      def object_to_ewkt(fragment, srid)
+        send("#{Charta.underscore(fragment.name)}_to_ewkt", fragment, srid)
+      end
+
+      def document_to_ewkt(gml, srid)
+        # whole document
+        if gml.css("#{OGR_PREFIX}|FeatureCollection").nil? || gml.css("#{GML_PREFIX}|featureMember").nil?
+          # fragment
+          if gml.root.name && TAGS.include?(gml.root.name)
+            object_to_ewkt(gml.root, srid)
+          else
+            'GEOMETRYCOLLECTION EMPTY'
+          end
+        else
+          'GEOMETRYCOLLECTION(' + gml.css("#{GML_PREFIX}|featureMember").collect do |feature|
+            TAGS.collect do |tag|
+              next if feature.css("#{GML_PREFIX}|#{tag}").empty?
+              feature.css("#{GML_PREFIX}|#{tag}").collect do |fragment|
+                object_to_ewkt(fragment, srid)
+              end.compact.join(', ')
+            end.compact.join(', ')
+          end.compact.join(', ') + ')'
+        end
+      end
+      alias geometry_collection_to_ewkt document_to_ewkt
+
+      def transform(data, from_srid, to_srid)
+        Charta.new_geometry(data, from_srid).transform(to_srid).to_text
+      end
+
+      def polygon_to_ewkt(gml, srid)
+        return 'POLYGON EMPTY' if gml.css("#{GML_PREFIX}|coordinates").nil?
+
+        wkt = 'POLYGON(' + %w[outerBoundaryIs innerBoundaryIs].collect do |boundary|
+          next if gml.css("#{GML_PREFIX}|#{boundary}").empty?
+          gml.css("#{GML_PREFIX}|#{boundary}").collect do |hole|
+            '(' + hole.css("#{GML_PREFIX}|coordinates").collect { |coords| coords.content.split(/\r\n|\n| /) }.flatten.reject(&:empty?).collect { |c| c.split ',' }.collect { |dimension| %(#{dimension.first} #{dimension[1]}) }.join(', ') + ')'
+          end.join(', ')
+        end.compact.join(', ') + ')'
+
+        unless gml['srsName'].nil? || Charta.find_srid(gml['srsName']).to_s == srid.to_s
+          wkt = transform(wkt, Charta.find_srid(gml['srsName']), srid)
+        end
+
+        wkt
+      end
+
+      def point_to_ewkt(gml, srid)
+        return 'POINT EMPTY' if gml.css("#{GML_PREFIX}|coordinates").nil?
+        wkt = 'POINT(' + gml.css("#{GML_PREFIX}|coordinates").collect { |coords| coords.content.split ',' }.flatten.join(' ') + ')'
+
+        unless gml['srsName'].nil? || Charta.find_srid(gml['srsName']).to_s == srid.to_s
+          wkt = transform(wkt, Charta.find_srid(gml['srsName']), srid)
+        end
+
+        wkt
+      end
+
+      def line_string_to_ewkt(gml, srid)
+        return 'LINESTRING EMPTY' if gml.css("#{GML_PREFIX}|coordinates").nil?
+
+        wkt = 'LINESTRING(' + gml.css("#{GML_PREFIX}|coordinates").collect { |coords| coords.content.split(/\r\n|\n| /) }.flatten.reject(&:empty?).collect { |c| c.split ',' }.collect { |dimension| %(#{dimension.first} #{dimension[1]}) }.join(', ') + ')'
+
+        unless gml['srsName'].nil? || Charta.find_srid(gml['srsName']).to_s == srid.to_s
+          wkt = transform(wkt, Charta.find_srid(gml['srsName']), srid)
+        end
+
+        wkt
+      end
+    end
+  end
+end