rgeo-dschee 0.5.4

data/lib/rgeo/geographic/simple_mercator_projector.rb

@@ -0,0 +1,110 @@
+# -----------------------------------------------------------------------------
+#
+# Simple mercator projection
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module Geographic
+    class SimpleMercatorProjector # :nodoc:
+      EQUATORIAL_RADIUS = 6_378_137.0
+
+      def initialize(geography_factory_, opts_ = {})
+        @geography_factory = geography_factory_
+        @projection_factory = Cartesian.preferred_factory(srid: 3857,
+                                                          proj4: SimpleMercatorProjector._proj4_3857,
+                                                          coord_sys: SimpleMercatorProjector._coordsys_3857,
+                                                          buffer_resolution: opts_[:buffer_resolution],
+                                                          lenient_multi_polygon_assertions: opts_[:lenient_multi_polygon_assertions],
+                                                          uses_lenient_assertions: opts_[:uses_lenient_assertions],
+                                                          has_z_coordinate: opts_[:has_z_coordinate],
+                                                          has_m_coordinate: opts_[:has_m_coordinate])
+      end
+
+      def _set_factories(geography_factory_, projection_factory_) # :nodoc:
+        @geography_factory = geography_factory_
+        @projection_factory = projection_factory_
+      end
+
+      attr_reader :projection_factory
+
+      def project(geometry_)
+        case geometry_
+        when Feature::Point
+          rpd_ = ImplHelper::Math::RADIANS_PER_DEGREE
+          radius_ = EQUATORIAL_RADIUS
+          @projection_factory.point(geometry_.x * rpd_ * radius_,
+            ::Math.log(::Math.tan(::Math::PI / 4.0 + geometry_.y * rpd_ / 2.0)) * radius_)
+        when Feature::Line
+          @projection_factory.line(project(geometry_.start_point), project(geometry_.end_point))
+        when Feature::LinearRing
+          @projection_factory.linear_ring(geometry_.points.map { |p_| project(p_) })
+        when Feature::LineString
+          @projection_factory.line_string(geometry_.points.map { |p_| project(p_) })
+        when Feature::Polygon
+          @projection_factory.polygon(project(geometry_.exterior_ring),
+                                      geometry_.interior_rings.map { |p_| project(p_) })
+        when Feature::MultiPoint
+          @projection_factory.multi_point(geometry_.map { |p_| project(p_) })
+        when Feature::MultiLineString
+          @projection_factory.multi_line_string(geometry_.map { |p_| project(p_) })
+        when Feature::MultiPolygon
+          @projection_factory.multi_polygon(geometry_.map { |p_| project(p_) })
+        when Feature::GeometryCollection
+          @projection_factory.collection(geometry_.map { |p_| project(p_) })
+        end
+      end
+
+      def unproject(geometry_)
+        case geometry_
+        when Feature::Point
+          dpr_ = ImplHelper::Math::DEGREES_PER_RADIAN
+          radius_ = EQUATORIAL_RADIUS
+          @geography_factory.point(geometry_.x / radius_ * dpr_,
+            (2.0 * ::Math.atan(::Math.exp(geometry_.y / radius_)) - ::Math::PI / 2.0) * dpr_)
+        when Feature::Line
+          @geography_factory.line(unproject(geometry_.start_point), unproject(geometry_.end_point))
+        when Feature::LinearRing
+          @geography_factory.linear_ring(geometry_.points.map { |p_| unproject(p_) })
+        when Feature::LineString
+          @geography_factory.line_string(geometry_.points.map { |p_| unproject(p_) })
+        when Feature::Polygon
+          @geography_factory.polygon(unproject(geometry_.exterior_ring),
+            geometry_.interior_rings.map { |p_| unproject(p_) })
+        when Feature::MultiPoint
+          @geography_factory.multi_point(geometry_.map { |p_| unproject(p_) })
+        when Feature::MultiLineString
+          @geography_factory.multi_line_string(geometry_.map { |p_| unproject(p_) })
+        when Feature::MultiPolygon
+          @geography_factory.multi_polygon(geometry_.map { |p_| unproject(p_) })
+        when Feature::GeometryCollection
+          @geography_factory.collection(geometry_.map { |p_| unproject(p_) })
+        end
+      end
+
+      def wraps?
+        true
+      end
+
+      def limits_window
+        @limits_window ||= ProjectedWindow.new(@geography_factory,
+          -20_037_508.342789, -20_037_508.342789, 20_037_508.342789, 20_037_508.342789,
+          is_limits: true)
+      end
+
+      def self._proj4_3857 # :nodoc:
+        unless defined?(@proj4_3857)
+          @proj4_3857 = CoordSys::Proj4.create("+proj=merc +lon_0=0 +k=1 +x_0=0 +y_0=0 +a=6378137 +b=6378137 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs")
+        end
+        @proj4_3857
+      end
+
+      def self._coordsys_3857 # :nodoc:
+        unless defined?(@coordsys_3857)
+          @coordsys_3857 = CoordSys::CS.create_from_wkt('PROJCS["Popular Visualisation CRS / Mercator",GEOGCS["Popular Visualisation CRS",DATUM["Popular_Visualisation_Datum",SPHEROID["Popular Visualisation Sphere",6378137,0,AUTHORITY["EPSG","7059"]],TOWGS84[0,0,0,0,0,0,0],AUTHORITY["EPSG","6055"]],PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],UNIT["degree",0.01745329251994328,AUTHORITY["EPSG","9122"]],AUTHORITY["EPSG","4055"]],UNIT["metre",1,AUTHORITY["EPSG","9001"]],PROJECTION["Mercator_1SP"],PARAMETER["central_meridian",0],PARAMETER["scale_factor",1],PARAMETER["false_easting",0],PARAMETER["false_northing",0],AUTHORITY["EPSG","3785"],AXIS["X",EAST],AXIS["Y",NORTH]]')
+        end
+        @coordsys_3857
+      end
+    end
+  end
+end

data/lib/rgeo/geographic/spherical_feature_classes.rb

@@ -0,0 +1,100 @@
+# -----------------------------------------------------------------------------
+#
+# Spherical geographic feature classes
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module Geographic
+    class SphericalPointImpl # :nodoc:
+      include Feature::Point
+      include ImplHelper::BasicGeometryMethods
+      include ImplHelper::BasicPointMethods
+      include SphericalGeometryMethods
+      include SphericalPointMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::Point).include_in_class(self, true)
+    end
+
+    class SphericalLineStringImpl # :nodoc:
+      include Feature::LineString
+      include ImplHelper::BasicGeometryMethods
+      include ImplHelper::BasicLineStringMethods
+      include SphericalGeometryMethods
+      include SphericalLineStringMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::LineString).include_in_class(self, true)
+    end
+
+    class SphericalLineImpl # :nodoc:
+      include Feature::Line
+      include ImplHelper::BasicGeometryMethods
+      include ImplHelper::BasicLineStringMethods
+      include ImplHelper::BasicLineMethods
+      include SphericalGeometryMethods
+      include SphericalLineStringMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::Line).include_in_class(self, true)
+    end
+
+    class SphericalLinearRingImpl # :nodoc:
+      include Feature::LinearRing
+      include ImplHelper::BasicGeometryMethods
+      include ImplHelper::BasicLineStringMethods
+      include ImplHelper::BasicLinearRingMethods
+      include SphericalGeometryMethods
+      include SphericalLineStringMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::LinearRing).include_in_class(self, true)
+    end
+
+    class SphericalPolygonImpl # :nodoc:
+      include Feature::Polygon
+      include ImplHelper::BasicGeometryMethods
+      include ImplHelper::BasicPolygonMethods
+      include SphericalGeometryMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::Polygon).include_in_class(self, true)
+    end
+
+    class SphericalGeometryCollectionImpl # :nodoc:
+      include Feature::GeometryCollection
+      include ImplHelper::BasicGeometryMethods
+      include ImplHelper::BasicGeometryCollectionMethods
+      include SphericalGeometryMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::GeometryCollection).include_in_class(self, true)
+    end
+
+    class SphericalMultiPointImpl # :nodoc:
+      include Feature::MultiPoint
+      include ImplHelper::BasicGeometryMethods
+      include ImplHelper::BasicGeometryCollectionMethods
+      include ImplHelper::BasicMultiPointMethods
+      include SphericalGeometryMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiPoint).include_in_class(self, true)
+    end
+
+    class SphericalMultiLineStringImpl # :nodoc:
+      include Feature::MultiLineString
+      include ImplHelper::BasicGeometryMethods
+      include ImplHelper::BasicGeometryCollectionMethods
+      include ImplHelper::BasicMultiLineStringMethods
+      include SphericalGeometryMethods
+      include SphericalMultiLineStringMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiLineString).include_in_class(self, true)
+    end
+
+    class SphericalMultiPolygonImpl # :nodoc:
+      include Feature::MultiPolygon
+      include ImplHelper::BasicGeometryMethods
+      include ImplHelper::BasicGeometryCollectionMethods
+      include ImplHelper::BasicMultiPolygonMethods
+      include SphericalGeometryMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiPolygon).include_in_class(self, true)
+    end
+  end
+end

data/lib/rgeo/geographic/spherical_feature_methods.rb

@@ -0,0 +1,134 @@
+# -----------------------------------------------------------------------------
+#
+# Spherical geographic common methods
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module Geographic
+    module SphericalGeometryMethods # :nodoc:
+      def srid
+        factory.srid
+      end
+    end
+
+    module SphericalPointMethods # :nodoc:
+      def _validate_geometry
+        if @x < -180.0 || @x > 180.0
+          @x = @x % 360.0
+          @x -= 360.0 if @x > 180.0
+        end
+        @y = 90.0 if @y > 90.0
+        @y = -90.0 if @y < -90.0
+        super
+      end
+
+      def _xyz
+        @xyz ||= SphericalMath::PointXYZ.from_latlon(@y, @x)
+      end
+
+      def distance(rhs_)
+        rhs_ = Feature.cast(rhs_, @factory)
+        case rhs_
+        when SphericalPointImpl
+          _xyz.dist_to_point(rhs_._xyz) * SphericalMath::RADIUS
+        else
+          super
+        end
+      end
+
+      def equals?(rhs_)
+        return false unless rhs_.is_a?(self.class) && rhs_.factory == factory
+        case rhs_
+        when Feature::Point
+          if @y == 90
+            rhs_.y == 90
+          elsif @y == -90
+            rhs_.y == -90
+          else
+            rhs_.x == @x && rhs_.y == @y
+          end
+        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 buffer(distance_)
+        radius_ = distance_ / SphericalMath::RADIUS
+        radius_ = 1.5 if radius_ > 1.5
+        cos_ = ::Math.cos(radius_)
+        sin_ = ::Math.sin(radius_)
+        point_count_ = factory.property(:buffer_resolution) * 4
+        p0_ = _xyz
+        p1_ = p0_.create_perpendicular
+        p2_ = p1_ % p0_
+        angle_ = ::Math::PI * 2.0 / point_count_
+        points_ = (0...point_count_).map do |i_|
+          r_ = angle_ * i_
+          pi_ = SphericalMath::PointXYZ.weighted_combination(p1_, ::Math.cos(r_), p2_, ::Math.sin(r_))
+          p_ = SphericalMath::PointXYZ.weighted_combination(p0_, cos_, pi_, sin_)
+          factory.point(*p_.lonlat)
+        end
+        factory.polygon(factory.linear_ring(points_))
+      end
+
+      def self.included(klass_)
+        klass_.module_eval do
+          alias_method :longitude, :x
+          alias_method :lon, :x
+          alias_method :latitude, :y
+          alias_method :lat, :y
+        end
+      end
+    end
+
+    module SphericalLineStringMethods # :nodoc:
+      def _arcs
+        unless defined?(@arcs)
+          @arcs = (0..num_points - 2).map do |i_|
+            SphericalMath::ArcXYZ.new(point_n(i_)._xyz, point_n(i_ + 1)._xyz)
+          end
+        end
+        @arcs
+      end
+
+      def is_simple?
+        arcs_ = _arcs
+        len_ = arcs_.length
+        return false if arcs_.any?(&:degenerate?)
+        return true if len_ == 1
+        return arcs_[0].s != arcs_[1].e if len_ == 2
+        arcs_.each_with_index do |arc_, index_|
+          nindex_ = index_ + 1
+          nindex_ = nil if nindex_ == len_
+          return false if nindex_ && arc_.contains_point?(arcs_[nindex_].e)
+          pindex_ = index_ - 1
+          pindex_ = nil if pindex_ < 0
+          return false if pindex_ && arc_.contains_point?(arcs_[pindex_].s)
+          next unless nindex_
+          oindex_ = nindex_ + 1
+          while oindex_ < len_
+            oarc_ = arcs_[oindex_]
+            return false if !(index_ == 0 && oindex_ == len_ - 1 && arc_.s == oarc_.e) && arc_.intersects_arc?(oarc_)
+            oindex_ += 1
+          end
+        end
+        true
+      end
+
+      def length
+        _arcs.inject(0.0) { |sum_, arc_| sum_ + arc_.length } * SphericalMath::RADIUS
+      end
+    end
+
+    module SphericalMultiLineStringMethods # :nodoc:
+      def length
+        inject(0.0) { |sum_, geom_| sum_ + geom_.length }
+      end
+    end
+  end
+end

data/lib/rgeo/geographic/spherical_math.rb

@@ -0,0 +1,188 @@
+# -----------------------------------------------------------------------------
+#
+# Core calculations on the sphere
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module Geographic
+    module SphericalMath # :nodoc:
+      RADIUS = 6_378_137.0
+
+      # Represents a point on the unit sphere in (x,y,z) coordinates
+      # instead of lat-lon. This form is often faster, more convenient,
+      # and more numerically stable for certain computations.
+      #
+      # The coordinate system is a right-handed system where the z-axis
+      # goes through the north pole, the x-axis goes through the prime
+      # meridian, and the y-axis goes through +90 degrees longitude.
+      #
+      # This object is also used to represent a great circle, as its axis
+      # of rotation.
+
+      class PointXYZ # :nodoc:
+        def initialize(x_, y_, z_)
+          r_ = ::Math.sqrt(x_ * x_ + y_ * y_ + z_ * z_)
+          @x = (x_ / r_).to_f
+          @y = (y_ / r_).to_f
+          @z = (z_ / r_).to_f
+          raise "Not a number" if @x.nan? || @y.nan? || @z.nan?
+        end
+
+        def to_s
+          "(#{@x}, #{@y}, #{@z})"
+        end
+
+        attr_reader :x
+        attr_reader :y
+        attr_reader :z
+
+        def eql?(rhs_)
+          rhs_.is_a?(PointXYZ) && @x == rhs_.x && @y == rhs_.y && @z == rhs_.z
+        end
+        alias_method :==, :eql?
+
+        def latlon
+          lat_rad_ = ::Math.asin(@z)
+          lon_rad_ = begin
+                       ::Math.atan2(@y, @x)
+                     rescue
+                       0.0
+                     end
+          rpd_ = ImplHelper::Math::RADIANS_PER_DEGREE
+          [lat_rad_ / rpd_, lon_rad_ / rpd_]
+        end
+
+        def lonlat
+          lat_rad_ = ::Math.asin(@z)
+          lon_rad_ = begin
+                       ::Math.atan2(@y, @x)
+                     rescue
+                       0.0
+                     end
+          rpd_ = ImplHelper::Math::RADIANS_PER_DEGREE
+          [lon_rad_ / rpd_, lat_rad_ / rpd_]
+        end
+
+        def *(rhs_)
+          val_ = @x * rhs_.x + @y * rhs_.y + @z * rhs_.z
+          val_ = 1.0 if val_ > 1.0
+          val_ = -1.0 if val_ < -1.0
+          val_
+        end
+
+        def %(rhs_)
+          rx_ = rhs_.x
+          ry_ = rhs_.y
+          rz_ = rhs_.z
+          begin
+            PointXYZ.new(@y * rz_ - @z * ry_, @z * rx_ - @x * rz_, @x * ry_ - @y * rx_)
+          rescue
+            nil
+          end
+        end
+
+        def dist_to_point(rhs_)
+          rx_ = rhs_.x
+          ry_ = rhs_.y
+          rz_ = rhs_.z
+          dot_ = @x * rx_ + @y * ry_ + @z * rz_
+          if dot_ > -0.8 && dot_ < 0.8
+            ::Math.acos(dot_)
+          else
+            x_ = @y * rz_ - @z * ry_
+            y_ = @z * rx_ - @x * rz_
+            z_ = @x * ry_ - @y * rx_
+            as_ = ::Math.asin(::Math.sqrt(x_ * x_ + y_ * y_ + z_ * z_))
+            dot_ > 0.0 ? as_ : ::Math::PI - as_
+          end
+        end
+
+        # Creates some point that is perpendicular to this point
+
+        def create_perpendicular
+          p1dot_ = self * P1
+          p2dot_ = self * P2
+          p1dot_ = -p1dot_ if p1dot_ < 0
+          p2dot_ = -p2dot_ if p2dot_ < 0
+          p1dot_ < p2dot_ ? (self % P1) : (self % P2)
+        end
+
+        def self.from_latlon(lat_, lon_)
+          rpd_ = ImplHelper::Math::RADIANS_PER_DEGREE
+          lat_rad_ = rpd_ * lat_
+          lon_rad_ = rpd_ * lon_
+          z_ = ::Math.sin(lat_rad_)
+          r_ = ::Math.cos(lat_rad_)
+          x_ = ::Math.cos(lon_rad_) * r_
+          y_ = ::Math.sin(lon_rad_) * r_
+          new(x_, y_, z_)
+        end
+
+        def self.weighted_combination(p1_, w1_, p2_, w2_)
+          new(p1_.x * w1_ + p2_.x * w2_, p1_.y * w1_ + p2_.y * w2_, p1_.z * w1_ + p2_.z * w2_)
+        end
+
+        P1 = new(1, 0, 0)
+        P2 = new(0, 1, 0)
+      end
+
+      # Represents a finite arc on the sphere.
+
+      class ArcXYZ # :nodoc:
+        def initialize(start_, end_)
+          @s = start_
+          @e = end_
+          @axis = false
+        end
+
+        attr_reader :s
+        attr_reader :e
+
+        def to_s
+          "#{@s} - #{@e}"
+        end
+
+        def eql?(rhs_)
+          rhs_.is_a?(ArcXYZ) && @s == rhs_.s && @e == rhs_.e
+        end
+        alias_method :==, :eql?
+
+        def degenerate?
+          axis_ = axis
+          axis_.x == 0 && axis_.y == 0 && axis_.z == 0
+        end
+
+        def axis
+          @axis = @s % @e if @axis == false
+          @axis
+        end
+
+        def contains_point?(obj_)
+          axis_ = axis
+          saxis_ = ArcXYZ.new(@s, obj_).axis
+          eaxis_ = ArcXYZ.new(obj_, @e).axis
+          !saxis_ || !eaxis_ || obj_ * axis_ == 0.0 && saxis_ * axis_ > 0 && eaxis_ * axis_ > 0
+        end
+
+        def intersects_arc?(obj_)
+          my_axis_ = axis
+          dot1_ = my_axis_ * obj_.s
+          dot2_ = my_axis_ * obj_.e
+          if dot1_ >= 0.0 && dot2_ <= 0.0 || dot1_ <= 0.0 && dot2_ >= 0.0
+            ob_axis_ = obj_.axis
+            dot1_ = ob_axis_ * @s
+            dot2_ = ob_axis_ * @e
+            dot1_ >= 0.0 && dot2_ <= 0.0 || dot1_ <= 0.0 && dot2_ >= 0.0
+          else
+            false
+          end
+        end
+
+        def length
+          @s.dist_to_point(@e)
+        end
+      end
+    end
+  end
+end