rgeo-dschee 0.5.4

data/lib/rgeo.rb

@@ -0,0 +1,89 @@
+# RGeo is a spatial data library for Ruby. It focuses on the storage and
+# manipulation of spatial data types such as points, lines, and polygons.
+#
+# RGeo comprises a number of modules. The "rgeo" gem provides a suite of
+# standard modules. Additional optional modules are provided by separate
+# gems with names of the form "<tt>rgeo-*</tt>".
+#
+# === Standard modules
+#
+# These are the standard modules provided by the "rgeo" gem.
+#
+# * RGeo::Feature contains interface specifications for spatial
+#   objects implemented by RGeo. These interfaces closely follow the OGC
+#   Simple Features Specifiation (SFS). This module forms the core of RGeo.
+#
+# * RGeo::CoordSys contains classes for representing spatial
+#   reference systems and coordinate transformations. For example, it
+#   includes a wrapper for the Proj4 library, supporting many geographic
+#   projections.
+#
+# * RGeo::Cartesian is a gateway for geometric data implementations
+#   that operate in Caresian (flat) coordinate systems. It also provides a
+#   basic pure ruby Cartesian implementation. This implementation does not
+#   cover all the geometric analysis operations defined by the SFS, but it
+#   does not require an external C library and is often sufficient for
+#   basic applications.
+#
+# * RGeo::Geos is another Cartesian implementation that wraps the
+#   GEOS library to provide a full, high-performance implementation of
+#   Cartesian geometry that includes every operation defined in the SFS.
+#   It requires GEOS 3.2 or later.
+#
+# * RGeo::Geographic contains spatial implementations that operate
+#   in latitude-longitude coordinates and are well-suited for geographic
+#   location based applications. Geographic spatial objects may also be
+#   linked to projections.
+#
+# * RGeo::WKRep contains tools for reading and writing spatial
+#   data in the OGC Well-Known Text (WKT) and Well-Known Binary (WKB)
+#   representations. It also supports common variants such as the PostGIS
+#   EWKT and EWKB representations.
+#
+# === Optional Modules
+#
+# Here is a partial list of optional modules available as separate gems.
+#
+# * <b>rgeo-geojson</b> provides the RGeo::GeoJSON module, containing
+#   tools for GeoJSON encoding and decoding of spatial objects.
+#
+# * <b>rgeo-shapefile</b> provides the RGeo::Shapefile module, containing
+#   tools for reading ESRI shapefiles.
+#
+# * <b>rgeo-activerecord</b> provides the RGeo::ActiveRecord module,
+#   containing some ActiveRecord extensions for spatial databases, and a
+#   set of common tools for ActiveRecord spatial database adapters.
+#
+# Several ActiveRecord adapters use RGeo. These include:
+#
+# * <b>mysqlspatial</b>, an adapter for MySQL spatial extensions based on
+#   the mysql adapter. Available as the activerecord-mysqlspatial-adapter
+#   gem. <i>This adapter is deprecated due to bugs in the legacy mysql
+#   gem. You should use the mysql2spatial adapter instead.</i>
+#
+# * <b>mysql2spatial</b>, an adapter for MySQL spatial extensions based on
+#   the mysql2 adapter. Available as the activerecord-mysql2spatial-adapter
+#   gem.
+#
+# * <b>spatialite</b>, an adapter for the SpatiaLite extension to the
+#   Sqlite3 database, and based on the sqlite3 adapter. Available as the
+#   activerecord-spatialite-adapter gem.
+#
+# * <b>postgis</b>, an adapter for the PostGIS extension to the PostgreSQL
+#   database, and based on the postgresql adapter. Available as the
+#   activerecord-postgis-adapter gem.
+
+module RGeo
+end
+
+# Core modules
+require "rgeo/yaml"
+require "rgeo/version"
+require "rgeo/error"
+require "rgeo/feature"
+require "rgeo/coord_sys"
+require "rgeo/impl_helper"
+require "rgeo/wkrep"
+require "rgeo/geos"
+require "rgeo/cartesian"
+require "rgeo/geographic"

data/lib/rgeo/cartesian.rb

@@ -0,0 +1,25 @@
+# -----------------------------------------------------------------------------
+#
+# Cartesian features for RGeo
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  # The Cartesian module is a gateway to implementations that use the
+  # Cartesian (i.e. flat) coordinate system. It provides convenient
+  # access to Cartesian factories such as the Geos implementation and
+  # the simple Cartesian implementation. It also provides a namespace
+  # for Cartesian-specific analysis tools.
+
+  module Cartesian
+  end
+end
+
+# Implementation files.
+require "rgeo/cartesian/calculations"
+require "rgeo/cartesian/feature_methods"
+require "rgeo/cartesian/feature_classes"
+require "rgeo/cartesian/factory"
+require "rgeo/cartesian/interface"
+require "rgeo/cartesian/bounding_box"
+require "rgeo/cartesian/analysis"

data/lib/rgeo/cartesian/analysis.rb

@@ -0,0 +1,77 @@
+# -----------------------------------------------------------------------------
+#
+# Cartesian geometric analysis utilities
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module Cartesian
+    # This provides includes some spatial analysis algorithms supporting
+    # Cartesian data.
+
+    module Analysis
+      class << self
+        # Given a LineString, which must be a ring, determine whether the
+        # ring proceeds clockwise or counterclockwise.
+        # Returns 1 for counterclockwise, or -1 for clockwise.
+        #
+        # Returns 0 if the ring is empty.
+        # The return value is undefined if the object is not a ring, or
+        # is not in a Cartesian coordinate system.
+
+        def ring_direction(ring_)
+          size_ = ring_.num_points - 1
+          return 0 if size_ == 0
+
+          # Extract unit-length segments from the ring.
+          segs_ = []
+          size_.times do |i_|
+            p0_ = ring_.point_n(i_)
+            p1_ = ring_.point_n(i_ + 1)
+            x_ = p1_.x - p0_.x
+            y_ = p1_.y - p0_.y
+            r_ = ::Math.sqrt(x_ * x_ + y_ * y_)
+            if r_ > 0.0
+              segs_ << x_ / r_ << y_ / r_
+            else
+              size_ -= 1
+            end
+          end
+          segs_ << segs_[0] << segs_[1]
+
+          # Extract angles from the segments by subtracting the segments.
+          # Note angles are represented as cos/sin pairs so we don't
+          # have to calculate any trig functions.
+          angs_ = []
+          size_.times do |i_|
+            x0_, y0_, x1_, y1_ = segs_[i_ * 2, 4]
+            angs_ << x0_ * x1_ + y0_ * y1_ << x0_ * y1_ - x1_ * y0_
+          end
+
+          # Now add the angles and count revolutions.
+          # Again, our running sum is represented as a cos/sin pair.
+          revolutions_ = 0
+          sin_ = 0.0
+          cos_ = 1.0
+          angs_.each_slice(2) do |(x_, y_)|
+            ready_ = y_ > 0.0 && sin_ > 0.0 || y_ < 0.0 && sin_ < 0.0
+            if y_ != 0.0
+              s_ = sin_ * x_ + cos_ * y_
+              c_ = cos_ * x_ - sin_ * y_
+              r_ = ::Math.sqrt(s_ * s_ + c_ * c_)
+              sin_ = s_ / r_
+              cos_ = c_ / r_
+            end
+            next unless ready_
+            if y_ > 0.0 && sin_ <= 0.0
+              revolutions_ += 1
+            elsif y_ < 0.0 && sin_ >= 0.0
+              revolutions_ -= 1
+            end
+          end
+          revolutions_
+        end
+      end
+    end
+  end
+end

data/lib/rgeo/cartesian/bounding_box.rb

@@ -0,0 +1,398 @@
+# -----------------------------------------------------------------------------
+#
+# Cartesian bounding box
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module Cartesian
+    # This is a bounding box for Cartesian data.
+    # The simple cartesian implementation uses this internally to compute
+    # envelopes. You may also use it directly to compute and represent
+    # bounding boxes.
+    #
+    # A bounding box is a set of ranges in each dimension: X, Y, as well
+    # as Z and M if supported. You can compute a bounding box for one or
+    # more geometry objects by creating a new bounding box object, and
+    # adding the geometries to it. You may then query it for the bounds,
+    # or use it to determine whether it encloses other geometries or
+    # bounding boxes.
+
+    class BoundingBox
+      # Create a bounding box given two corner points.
+      # The bounding box will be given the factory of the first point.
+      # You may also provide the same options available to
+      # BoundingBox.new.
+
+      def self.create_from_points(point1_, point2_, opts_ = {})
+        factory_ = point1_.factory
+        new(factory_, opts_)._add_geometry(point1_).add(point2_)
+      end
+
+      # Create a bounding box given a geometry to surround.
+      # The bounding box will be given the factory of the geometry.
+      # You may also provide the same options available to
+      # BoundingBox.new.
+
+      def self.create_from_geometry(geom_, opts_ = {})
+        factory_ = geom_.factory
+        new(factory_, opts_)._add_geometry(geom_)
+      end
+
+      # Create a new empty bounding box with the given factory.
+      #
+      # The factory defines the coordinate system for the bounding box,
+      # and also defines whether it should track Z and M coordinates.
+      # All geometries will be cast to this factory when added to this
+      # bounding box, and any generated envelope geometry will have this
+      # as its factory.
+      #
+      # Options include:
+      #
+      # [<tt>:ignore_z</tt>]
+      #   If true, ignore z coordinates even if the factory supports them.
+      #   Default is false.
+      # [<tt>:ignore_m</tt>]
+      #   If true, ignore m coordinates even if the factory supports them.
+      #   Default is false.
+
+      def initialize(factory_, opts_ = {})
+        @factory = factory_
+        if (values_ = opts_[:raw])
+          @has_z, @has_m, @min_x, @max_x, @min_y, @max_y, @min_z, @max_z, @min_m, @max_m = values_
+        else
+          @has_z = !opts_[:ignore_z] && factory_.property(:has_z_coordinate) ? true : false
+          @has_m = !opts_[:ignore_m] && factory_.property(:has_m_coordinate) ? true : false
+          @min_x = @max_x = @min_y = @max_y = @min_z = @max_z = @min_m = @max_m = nil
+        end
+      end
+
+      def eql?(rhs_) # :nodoc:
+        rhs_.is_a?(BoundingBox) && @factory == rhs_.factory &&
+          @min_x == rhs_.min_x && @max_x == rhs_.max_x &&
+          @min_y == rhs_.min_y && @max_y == rhs_.max_y &&
+          @min_z == rhs_.min_z && @max_z == rhs_.max_z &&
+          @min_m == rhs_.min_m && @max_m == rhs_.max_m
+      end
+      alias_method :==, :eql?
+
+      # Returns the bounding box's factory.
+
+      attr_reader :factory
+
+      # Returns true if this bounding box is still empty.
+
+      def empty?
+        @min_x.nil?
+      end
+
+      # Returns true if this bounding box is degenerate. That is,
+      # it is nonempty but contains only a single point because both
+      # the X and Y spans are 0. Infinitesimal boxes are also
+      # always degenerate.
+
+      def infinitesimal?
+        @min_x && @min_x == @max_x && @min_y == @max_y
+      end
+
+      # Returns true if this bounding box is degenerate. That is,
+      # it is nonempty but has zero area because either or both
+      # of the X or Y spans are 0.
+
+      def degenerate?
+        @min_x && (@min_x == @max_x || @min_y == @max_y)
+      end
+
+      # Returns true if this bounding box tracks Z coordinates.
+
+      attr_reader :has_z
+
+      # Returns true if this bounding box tracks M coordinates.
+
+      attr_reader :has_m
+
+      # Returns the minimum X, or nil if this bounding box is empty.
+
+      attr_reader :min_x
+
+      # Returns the maximum X, or nil if this bounding box is empty.
+
+      attr_reader :max_x
+
+      # Returns the midpoint X, or nil if this bounding box is empty.
+
+      def center_x
+        @max_x ? (@max_x + @min_x) * 0.5 : nil
+      end
+
+      # Returns the X span, or 0 if this bounding box is empty.
+
+      def x_span
+        @max_x ? @max_x - @min_x : 0
+      end
+
+      # Returns the minimum Y, or nil if this bounding box is empty.
+
+      attr_reader :min_y
+
+      # Returns the maximum Y, or nil if this bounding box is empty.
+
+      attr_reader :max_y
+
+      # Returns the midpoint Y, or nil if this bounding box is empty.
+
+      def center_y
+        @max_y ? (@max_y + @min_y) * 0.5 : nil
+      end
+
+      # Returns the Y span, or 0 if this bounding box is empty.
+
+      def y_span
+        @max_y ? @max_y - @min_y : 0
+      end
+
+      # Returns the minimum Z, or nil if this bounding box is empty.
+
+      attr_reader :min_z
+
+      # Returns the maximum Z, or nil if this bounding box is empty.
+
+      attr_reader :max_z
+
+      # Returns the midpoint Z, or nil if this bounding box is empty or has no Z.
+
+      def center_z
+        @max_z ? (@max_z + @min_z) * 0.5 : nil
+      end
+
+      # Returns the Z span, 0 if this bounding box is empty, or nil if it has no Z.
+
+      def z_span
+        @has_z ? (@max_z ? @max_z - @min_z : 0) : nil
+      end
+
+      # Returns the minimum M, or nil if this bounding box is empty.
+
+      attr_reader :min_m
+
+      # Returns the maximum M, or nil if this bounding box is empty.
+
+      attr_reader :max_m
+
+      # Returns the midpoint M, or nil if this bounding box is empty or has no M.
+
+      def center_m
+        @max_m ? (@max_m + @min_m) * 0.5 : nil
+      end
+
+      # Returns the M span, 0 if this bounding box is empty, or nil if it has no M.
+
+      def m_span
+        @has_m ? (@max_m ? @max_m - @min_m : 0) : nil
+      end
+
+      # Returns a point representing the minimum extent in all dimensions,
+      # or nil if this bounding box is empty.
+
+      def min_point
+        if @min_x
+          extras_ = []
+          extras_ << @min_z if @has_z
+          extras_ << @min_m if @has_m
+          @factory.point(@min_x, @min_y, *extras_)
+        end
+      end
+
+      # Returns a point representing the maximum extent in all dimensions,
+      # or nil if this bounding box is empty.
+
+      def max_point
+        if @min_x
+          extras_ = []
+          extras_ << @max_z if @has_z
+          extras_ << @max_m if @has_m
+          @factory.point(@max_x, @max_y, *extras_)
+        end
+      end
+
+      # Adjusts the extents of this bounding box to encompass the given
+      # object, which may be a geometry or another bounding box.
+      # Returns self.
+
+      def add(geometry_)
+        case geometry_
+        when BoundingBox
+          add(geometry_.min_point)
+          add(geometry_.max_point)
+        when Feature::Geometry
+          if geometry_.factory == @factory
+            _add_geometry(geometry_)
+          else
+            _add_geometry(Feature.cast(geometry_, @factory))
+          end
+        end
+        self
+      end
+
+      # Converts this bounding box to an envelope, which will be the
+      # empty collection (if the bounding box is empty), a point (if the
+      # bounding box is not empty but both spans are 0), a line (if only
+      # one of the two spans is 0) or a polygon (if neither span is 0).
+
+      def to_geometry
+        if @min_x
+          extras_ = []
+          extras_ << @min_z if @has_z
+          extras_ << @min_m if @has_m
+          point_min_ = @factory.point(@min_x, @min_y, *extras_)
+          if infinitesimal?
+            point_min_
+          else
+            extras_ = []
+            extras_ << @max_z if @has_z
+            extras_ << @max_m if @has_m
+            point_max_ = @factory.point(@max_x, @max_y, *extras_)
+            if degenerate?
+              @factory.line(point_min_, point_max_)
+            else
+              @factory.polygon(@factory.linear_ring([point_min_,
+                                                     @factory.point(@max_x, @min_y, *extras_), point_max_,
+                                                     @factory.point(@min_x, @max_y, *extras_), point_min_]))
+            end
+          end
+        else
+          @factory.collection([])
+        end
+      end
+
+      # Returns true if this bounding box contains the given object,
+      # which may be a geometry or another bounding box.
+      #
+      # Supports these options:
+      #
+      # [<tt>:ignore_z</tt>]
+      #   Ignore the Z coordinate when testing, even if both objects
+      #   have Z. Default is false.
+      # [<tt>:ignore_m</tt>]
+      #   Ignore the M coordinate when testing, even if both objects
+      #   have M. Default is false.
+
+      def contains?(rhs_, opts_ = {})
+        if Feature::Geometry === rhs_
+          contains?(BoundingBox.new(@factory).add(rhs_))
+        elsif rhs_.empty?
+          true
+        elsif empty?
+          false
+        elsif @min_x > rhs_.min_x || @max_x < rhs_.max_x || @min_y > rhs_.min_y || @max_y < rhs_.max_y
+          false
+        elsif @has_m && rhs_.has_m && !opts_[:ignore_m] && (@min_m > rhs_.min_m || @max_m < rhs_.max_m)
+          false
+        elsif @has_z && rhs_.has_z && !opts_[:ignore_z] && (@min_z > rhs_.min_z || @max_z < rhs_.max_z)
+          false
+        else
+          true
+        end
+      end
+
+      # Returns this bounding box subdivided, as an array of bounding boxes.
+      # If this bounding box is empty, returns the empty array.
+      # If this bounding box is a point, returns a one-element array
+      # containing the current point.
+      # If the x or y span is 0, bisects the line.
+      # Otherwise, generally returns a 4-1 subdivision in the X-Y plane.
+      # Does not subdivide on Z or M.
+      #
+      # [<tt>:bisect_factor</tt>]
+      #   An optional floating point value that should be greater than 1.0.
+      #   If the ratio between the larger span and the smaller span is
+      #   greater than this factor, the bounding box is divided only in
+      #   half instead of fourths.
+
+      def subdivide(opts_ = {})
+        return [] if empty?
+        if infinitesimal?
+          return [
+            BoundingBox.new(@factory, raw: [@has_z, @has_m,
+                                            @min_x, @max_x, @min_y, @max_y, @min_z, @max_z, @min_m, @max_m])
+          ]
+        end
+        factor_ = opts_[:bisect_factor]
+        factor_ ||= 1 if degenerate?
+        if factor_
+          if x_span > y_span * factor_
+            return [
+              BoundingBox.new(@factory, raw: [@has_z, @has_m,
+                                              @min_x, center_x, @min_y, @max_y, @min_z, @max_z, @min_m, @max_m]),
+              BoundingBox.new(@factory, raw: [@has_z, @has_m,
+                                              center_x, @max_x, @min_y, @max_y, @min_z, @max_z, @min_m, @max_m])
+            ]
+          elsif y_span > x_span * factor_
+            return [
+              BoundingBox.new(@factory, raw: [@has_z, @has_m,
+                                              @min_x, @max_x, @min_y, center_y, @min_z, @max_z, @min_m, @max_m]),
+              BoundingBox.new(@factory, raw: [@has_z, @has_m,
+                                              @min_x, @max_x, center_y, @max_y, @min_z, @max_z, @min_m, @max_m])
+            ]
+          end
+        end
+        [
+          BoundingBox.new(@factory, raw: [@has_z, @has_m,
+                                          @min_x, center_x, @min_y, center_y, @min_z, @max_z, @min_m, @max_m]),
+          BoundingBox.new(@factory, raw: [@has_z, @has_m,
+                                          center_x, @max_x, @min_y, center_y, @min_z, @max_z, @min_m, @max_m]),
+          BoundingBox.new(@factory, raw: [@has_z, @has_m,
+                                          @min_x, center_x, center_y, @max_y, @min_z, @max_z, @min_m, @max_m]),
+          BoundingBox.new(@factory, raw: [@has_z, @has_m,
+                                          center_x, @max_x, center_y, @max_y, @min_z, @max_z, @min_m, @max_m])
+        ]
+      end
+
+      def _add_geometry(geometry_) # :nodoc:
+        case geometry_
+        when Feature::Point
+          _add_point(geometry_)
+        when Feature::LineString
+          geometry_.points.each { |p_| _add_point(p_) }
+        when Feature::Polygon
+          geometry_.exterior_ring.points.each { |p_| _add_point(p_) }
+        when Feature::MultiPoint
+          geometry_.each { |p_| _add_point(p_) }
+        when Feature::MultiLineString
+          geometry_.each { |line_| line_.points.each { |p_| _add_point(p_) } }
+        when Feature::MultiPolygon
+          geometry_.each { |poly_| poly_.exterior_ring.points.each { |p_| _add_point(p_) } }
+        when Feature::GeometryCollection
+          geometry_.each { |g_| _add_geometry(g_) }
+        end
+        self
+      end
+
+      def _add_point(point_) # :nodoc:
+        if @min_x
+          x_ = point_.x
+          @min_x = x_ if x_ < @min_x
+          @max_x = x_ if x_ > @max_x
+          y_ = point_.y
+          @min_y = y_ if y_ < @min_y
+          @max_y = y_ if y_ > @max_y
+          if @has_z
+            z_ = point_.z
+            @min_z = z_ if z_ < @min_z
+            @max_z = z_ if z_ > @max_z
+          end
+          if @has_m
+            m_ = point_.m
+            @min_m = m_ if m_ < @min_m
+            @max_m = m_ if m_ > @max_m
+          end
+        else
+          @min_x = @max_x = point_.x
+          @min_y = @max_y = point_.y
+          @min_z = @max_z = point_.z if @has_z
+          @min_m = @max_m = point_.m if @has_m
+        end
+      end
+    end
+  end
+end