rgeo-dschee 0.5.4

data/lib/rgeo/impl_helper/basic_geometry_methods.rb

@@ -0,0 +1,61 @@
+# -----------------------------------------------------------------------------
+#
+# Basic methods used by geometry objects
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module ImplHelper # :nodoc:
+    module BasicGeometryMethods # :nodoc:
+      include Feature::Instance
+
+      def inspect # :nodoc:
+        "#<#{self.class}:0x#{object_id.to_s(16)} #{as_text.inspect}>"
+      end
+
+      def to_s # :nodoc:
+        as_text
+      end
+
+      def _validate_geometry # :nodoc:
+      end
+
+      def _set_factory(factory_)  # :nodoc:
+        @factory = factory_
+      end
+
+      def factory
+        @factory
+      end
+
+      def as_text
+        @factory._generate_wkt(self)
+      end
+
+      def as_binary
+        @factory._generate_wkb(self)
+      end
+
+      def _copy_state_from(obj_)  # :nodoc:
+        @factory = obj_.factory
+      end
+
+      def marshal_dump # :nodoc:
+        [@factory, @factory._marshal_wkb_generator.generate(self)]
+      end
+
+      def marshal_load(data_)  # :nodoc:
+        _copy_state_from(data_[0]._marshal_wkb_parser.parse(data_[1]))
+      end
+
+      def encode_with(coder_)  # :nodoc:
+        coder_["factory"] = @factory
+        coder_["wkt"] = @factory._psych_wkt_generator.generate(self)
+      end
+
+      def init_with(coder_) # :nodoc:
+        _copy_state_from(coder_["factory"]._psych_wkt_parser.parse(coder_["wkt"]))
+      end
+    end
+  end
+end

data/lib/rgeo/impl_helper/basic_line_string_methods.rb

@@ -0,0 +1,146 @@
+# -----------------------------------------------------------------------------
+#
+# Common methods for LineString features
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module ImplHelper # :nodoc:
+    module BasicLineStringMethods # :nodoc:
+      def initialize(factory_, points_)
+        _set_factory(factory_)
+        @points = points_.map do |elem_|
+          elem_ = Feature.cast(elem_, factory_, Feature::Point)
+          raise Error::InvalidGeometry, "Could not cast #{elem_}" unless elem_
+          elem_
+        end
+        _validate_geometry
+      end
+
+      def _validate_geometry
+        if @points.size == 1
+          raise Error::InvalidGeometry, "LineString cannot have 1 point"
+        end
+      end
+
+      def num_points
+        @points.size
+      end
+
+      def point_n(n_)
+        n_ < 0 ? nil : @points[n_]
+      end
+
+      def points
+        @points.dup
+      end
+
+      def dimension
+        1
+      end
+
+      def geometry_type
+        Feature::LineString
+      end
+
+      def is_empty?
+        @points.size == 0
+      end
+
+      def boundary
+        array_ = []
+        array_ << @points.first << @points.last if !is_empty? && !is_closed?
+        factory.multi_point([array_])
+      end
+
+      def start_point
+        @points.first
+      end
+
+      def end_point
+        @points.last
+      end
+
+      def is_closed?
+        unless defined?(@is_closed)
+          @is_closed = @points.size > 2 && @points.first == @points.last
+        end
+        @is_closed
+      end
+
+      def is_ring?
+        is_closed? && is_simple?
+      end
+
+      def rep_equals?(rhs_)
+        if rhs_.is_a?(self.class) && rhs_.factory.eql?(@factory) && @points.size == rhs_.num_points
+          rhs_.points.each_with_index { |p_, i_| return false unless @points[i_].rep_equals?(p_) }
+        else
+          false
+        end
+      end
+
+      def hash
+        @hash ||= begin
+          hash_ = [factory, geometry_type].hash
+          @points.inject(hash_) { |h_, p_| (1_664_525 * h_ + p_.hash).hash }
+        end
+      end
+
+      def _copy_state_from(obj_) # :nodoc:
+        super
+        @points = obj_.points
+      end
+
+      def coordinates
+        @points.map(&:coordinates)
+      end
+    end
+
+    module BasicLineMethods # :nodoc:
+      def initialize(factory_, start_, end_)
+        _set_factory(factory_)
+        cstart_ = Feature.cast(start_, factory_, Feature::Point)
+        unless cstart_
+          raise Error::InvalidGeometry, "Could not cast start: #{start_}"
+        end
+        cend_ = Feature.cast(end_, factory_, Feature::Point)
+        raise Error::InvalidGeometry, "Could not cast end: #{end_}" unless cend_
+        @points = [cstart_, cend_]
+        _validate_geometry
+      end
+
+      def _validate_geometry # :nodoc:
+        super
+        if @points.size > 2
+          raise Error::InvalidGeometry, "Line must have 0 or 2 points"
+        end
+      end
+
+      def geometry_type
+        Feature::Line
+      end
+
+      def coordinates
+        @points.map(&:coordinates)
+      end
+    end
+
+    module BasicLinearRingMethods # :nodoc:
+      def _validate_geometry # :nodoc:
+        super
+        if @points.size > 0
+          @points << @points.first if @points.first != @points.last
+          @points = @points.chunk {|x| x}.map(&:first)
+          if !@factory.property(:uses_lenient_assertions) && !is_ring?
+            raise Error::InvalidGeometry, "LinearRing failed ring test"
+          end
+        end
+      end
+
+      def geometry_type
+        Feature::LinearRing
+      end
+    end
+  end
+end

data/lib/rgeo/impl_helper/basic_point_methods.rb

@@ -0,0 +1,104 @@
+# -----------------------------------------------------------------------------
+#
+# Common methods for Point features
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module ImplHelper # :nodoc:
+    module BasicPointMethods # :nodoc:
+      def initialize(factory_, x_, y_, *extra_)
+        _set_factory(factory_)
+        @x = x_.to_f
+        @y = y_.to_f
+        @z = factory_.property(:has_z_coordinate) ? extra_.shift.to_f : nil
+        @m = factory_.property(:has_m_coordinate) ? extra_.shift.to_f : nil
+        if extra_.size > 0
+          raise ::ArgumentError, "Too many arguments for point initializer"
+        end
+        _validate_geometry
+      end
+
+      def x
+        @x
+      end
+
+      def y
+        @y
+      end
+
+      def z
+        @z
+      end
+
+      def m
+        @m
+      end
+
+      def dimension
+        0
+      end
+
+      def geometry_type
+        Feature::Point
+      end
+
+      def is_empty?
+        false
+      end
+
+      def is_simple?
+        true
+      end
+
+      def envelope
+        self
+      end
+
+      def boundary
+        factory.collection([])
+      end
+
+      def convex_hull
+        self
+      end
+
+      def equals?(rhs_)
+        return false unless rhs_.is_a?(self.class) && rhs_.factory == factory
+        case rhs_
+        when Feature::Point
+          rhs_.x == @x && rhs_.y == @y
+        when Feature::LineString
+          rhs_.num_points > 0 && rhs_.points.all? { |elem_| equals?(elem_) }
+        when Feature::GeometryCollection
+          rhs_.num_geometries > 0 && rhs_.all? { |elem_| equals?(elem_) }
+        else
+          false
+        end
+      end
+
+      def rep_equals?(rhs_)
+        rhs_.is_a?(self.class) && rhs_.factory.eql?(@factory) && @x == rhs_.x && @y == rhs_.y && @z == rhs_.z && @m == rhs_.m
+      end
+
+      def hash
+        @hash ||= [factory, geometry_type, @x, @y, @z, @m].hash
+      end
+
+      def _copy_state_from(obj_) # :nodoc:
+        super
+        @x = obj_.x
+        @y = obj_.y
+        @z = obj_.z
+        @m = obj_.m
+      end
+
+      def coordinates
+        [x, y].tap do |coords|
+          coords << z if factory.property(:has_z_coordinate)
+          coords << m if factory.property(:has_m_coordinate)
+        end
+      end
+    end
+  end
+end

data/lib/rgeo/impl_helper/basic_polygon_methods.rb

@@ -0,0 +1,87 @@
+# -----------------------------------------------------------------------------
+#
+# Common methods for Polygon features
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module ImplHelper # :nodoc:
+    module BasicPolygonMethods # :nodoc:
+      def initialize(factory_, exterior_ring_, interior_rings_)
+        _set_factory(factory_)
+        @exterior_ring = Feature.cast(exterior_ring_, factory_, Feature::LinearRing)
+        unless @exterior_ring
+          raise Error::InvalidGeometry, "Failed to cast exterior ring #{exterior_ring_}"
+        end
+        @interior_rings = (interior_rings_ || []).map do |elem_|
+          elem_ = Feature.cast(elem_, factory_, Feature::LinearRing)
+          unless elem_
+            raise Error::InvalidGeometry, "Could not cast interior ring #{elem_}"
+          end
+          elem_
+        end
+        _validate_geometry
+      end
+
+      def exterior_ring
+        @exterior_ring
+      end
+
+      def num_interior_rings
+        @interior_rings.size
+      end
+
+      def interior_ring_n(n_)
+        n_ < 0 ? nil : @interior_rings[n_]
+      end
+
+      def interior_rings
+        @interior_rings.dup
+      end
+
+      def dimension
+        2
+      end
+
+      def geometry_type
+        Feature::Polygon
+      end
+
+      def is_empty?
+        @exterior_ring.is_empty?
+      end
+
+      def boundary
+        array_ = []
+        array_ << @exterior_ring unless @exterior_ring.is_empty?
+        array_.concat(@interior_rings)
+        factory.multi_line_string(array_)
+      end
+
+      def rep_equals?(rhs_)
+        if rhs_.is_a?(self.class) && rhs_.factory.eql?(@factory) && @exterior_ring.rep_equals?(rhs_.exterior_ring) && @interior_rings.size == rhs_.num_interior_rings
+          rhs_.interior_rings.each_with_index { |r_, i_| return false unless @interior_rings[i_].rep_equals?(r_) }
+        else
+          false
+        end
+      end
+
+      def hash
+        @hash ||= begin
+          hash_ = [geometry_type, @exterior_ring].hash
+          @interior_rings.inject(hash_) { |h_, r_| (1_664_525 * h_ + r_.hash).hash }
+        end
+      end
+
+      def _copy_state_from(obj_) # :nodoc:
+        super
+        @exterior_ring = obj_.exterior_ring
+        @interior_rings = obj_.interior_rings
+      end
+
+      def coordinates
+        ([@exterior_ring] + @interior_rings).map(&:coordinates)
+      end
+    end
+  end
+end

data/lib/rgeo/impl_helper/math.rb

@@ -0,0 +1,14 @@
+# -----------------------------------------------------------------------------
+#
+# Math constants and tools
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module ImplHelper # :nodoc:
+    module Math # :nodoc:
+      RADIANS_PER_DEGREE = ::Math::PI / 180.0
+      DEGREES_PER_RADIAN = 180.0 / ::Math::PI
+    end
+  end
+end

data/lib/rgeo/impl_helper/utils.rb

@@ -0,0 +1,29 @@
+# -----------------------------------------------------------------------------
+#
+# Math constants and tools
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module ImplHelper # :nodoc:
+    module Utils # :nodoc:
+      class << self
+        def stringize_hash(hash_)
+          nhash_ = {}
+          hash_.each do |k_, v_|
+            nhash_[k_.is_a?(::Symbol) ? k_.to_s : k_] = v_.is_a?(::Symbol) ? v_.to_s : v_
+          end
+          nhash_
+        end
+
+        def symbolize_hash(hash_)
+          nhash_ = {}
+          hash_.each do |k_, v_|
+            nhash_[k_.is_a?(::String) ? k_.to_sym : k_] = v_.is_a?(::String) ? v_.to_sym : v_
+          end
+          nhash_
+        end
+      end
+    end
+  end
+end