geos-extensions 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6f5adfee693cca7bcf4ddf2aa10487d225c0c542
-  data.tar.gz: ec1a90597c0676234ea1493331aff022f89699fd
+  metadata.gz: 376ec274e23a76e893dfe82e9a129328b8c22802
+  data.tar.gz: b9b7638b716febc1f4cf5f073ae33d3f11a79e02
 SHA512:
-  metadata.gz: 60eb6880603184b2545c6642ca97e870dfd8f87fccc1fc517fa959c532bcb50b4919a41025a5b085128d098d0324240c20d8b8747e4bfec130480f20052b8e5d
-  data.tar.gz: cfd7ee85ece68614b1c271751de00c9664273420c56cd28d73066d4db8e95dca29541ba542679a3ae4d2a274400ba0930786ec8662ed2b23620c789e05e20e0e
+  metadata.gz: 06d9bb0eaabeb674ed1e6569894e06bb928f932326143e821772e2732486fb82822feada9db361b727321398fa351a3fc899ba6951f8e789897eb0cc5429ab01
+  data.tar.gz: 57d7ef96672139403b437f3c755d32280a20ac2c34e79b8eb3e36f5961d0f9867fe989475a4ce62f7f3423289a0808c16c2589e14069026f569ff27811681169

data/.travis.yml

@@ -0,0 +1,17 @@
+cache: bundler
+sudo: false
+language: ruby
+rvm:
+  - 2.4.0
+  - 2.3.3
+  - 2.2.6
+  - rbx-3
+  - jruby-19mode
+matrix:
+  allow_failures:
+    - rvm: rbx-3
+    - rvm: jruby-19mode
+addons:
+  apt:
+    packages:
+      - libgeos-c1

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2008-2016 J Smith <dark.panda@gmail.com>
+Copyright (c) 2008-2017 J Smith <dark.panda@gmail.com>
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

data/Rakefile

@@ -26,3 +26,5 @@ Rake::RDocTask.new do |t|
   t.rdoc_files.include('README.rdoc', 'MIT-LICENSE', 'lib/**/*.rb')
 end
 
+task :default => :test
+

data/lib/geos-extensions.rb

@@ -1,5 +1,11 @@
+# encoding: UTF-8
+# frozen_string_literal: true
 
 require File.join(File.dirname(__FILE__), *%w{ geos_extensions })
 
 Geos::GoogleMaps.use_api(3)
 
+module Geos
+  class InvalidGeometryError < Geos::Error
+  end
+end

data/lib/geos/coordinate_sequence.rb

@@ -1,18 +1,8 @@
+# encoding: UTF-8
+# frozen_string_literal: true
 
 module Geos
   class CoordinateSequence
-    # Returns a Ruby Array of Arrays of coordinates within the
-    # CoordinateSequence in the form [ x, y, z ].
-    def to_a
-      (0...self.length).to_a.collect do |p|
-        [
-          self.get_x(p),
-          (self.dimensions >= 2 ? self.get_y(p) : nil),
-          (self.dimensions >= 3 && self.get_z(p) > 1.7e-306 ? self.get_z(p) : nil)
-        ].compact
-      end
-    end
-
     # Build some XmlMarkup for KML. You can set various KML options like
     # tessellate, altitudeMode, etc. Use Rails/Ruby-style code and it
     # will be converted automatically, i.e. :altitudeMode, not
@@ -87,6 +77,294 @@ module Geos
     def to_geojson(options = {})
       self.to_geojsonable(options).to_json
     end
+
+    %w{ x y z }.each do |m|
+      class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+        def #{m}_max
+          ret = nil
+          self.length.times do |i|
+            value = self.get_#{m}(i)
+            ret = value if !ret || value >= ret
+          end
+          ret
+        end
+
+        def #{m}_min
+          ret = nil
+          self.length.times do |i|
+            value = self.get_#{m}(i)
+            ret = value if !ret || value <= ret
+          end
+          ret
+        end
+      EOF
+    end
+
+    def snap_to_grid!(*args)
+      grid = {
+        :offset_x => 0, # 1
+        :offset_y => 0, # 2
+        :offset_z => 0, # -
+        :size_x => 0, # 3
+        :size_y => 0, # 4
+        :size_z => 0 # -
+      }
+
+      if args.length == 1 && args[0].is_a?(Numeric)
+        grid[:size_x] = grid[:size_y] = grid[:size_z] = args[0]
+      elsif args[0].is_a?(Hash)
+        grid.merge!(args[0])
+      end
+
+      if grid[:size]
+        grid[:size_x] = grid[:size_y] = grid[:size_z] = grid[:size]
+      end
+
+      if grid[:offset]
+        case grid[:offset]
+          when Geos::Geometry
+            point = grid[:offset].centroid
+
+            grid[:offset_x] = point.x
+            grid[:offset_y] = point.y
+            grid[:offset_z] = point.z
+          when Array
+            grid[:offset_x], grid[:offset_y], grid[:offset_z] = grid[:offset]
+          else
+            raise ArgumentError.new("Expected :offset option to be a Geos::Point")
+        end
+      end
+
+      self.length.times do |i|
+        if grid[:size_x] != 0
+          self.x[i] = ((self.x[i] - grid[:offset_x]) / grid[:size_x]).round * grid[:size_x] + grid[:offset_x]
+        end
+
+        if grid[:size_y] != 0
+          self.y[i] = ((self.y[i] - grid[:offset_y]) / grid[:size_y]).round * grid[:size_y] + grid[:offset_y]
+        end
+
+        if self.has_z? && grid[:size_z] != 0
+          self.z[i] = ((self.z[i] - grid[:offset_z]) / grid[:size_z]).round * grid[:size_z] + grid[:offset_z]
+        end
+      end
+
+      cs = self.remove_duplicate_coords
+      @ptr = cs.ptr
+
+      self
+    end
+
+    def snap_to_grid(*args)
+      self.dup.snap_to_grid!(*args)
+    end
+
+    def remove_duplicate_coords
+      Geos::CoordinateSequence.new(self.to_a.inject([]) { |memo, v|
+        memo << v unless memo.last == v
+        memo
+      })
+    end
+
+    def affine!(options)
+      options.default = 0.0
+
+      if self.has_z?
+        self.length.times do |i|
+          x, y, z = self.x[i], self.y[i], self.z[i]
+
+          self.x[i] = options[:afac] * x + options[:bfac] * y + options[:cfac] * z + options[:xoff]
+          self.y[i] = options[:dfac] * x + options[:efac] * y + options[:ffac] * z + options[:yoff]
+          self.z[i] = options[:gfac] * x + options[:hfac] * y + options[:ifac] * z + options[:zoff]
+        end
+      else
+        self.length.times do |i|
+          x, y = self.x[i], self.y[i]
+
+          self.x[i] = options[:afac] * x + options[:bfac] * y + options[:xoff]
+          self.y[i] = options[:dfac] * x + options[:efac] * y + options[:yoff]
+        end
+      end
+
+      self
+    end
+
+    def affine(options)
+      self.dup.affine!(options)
+    end
+
+    def rotate!(radians, origin = [ 0.0, 0.0 ])
+      origin = case origin
+        when Array
+          origin
+        when Geos::Geometry
+          center = origin.centroid
+          [ center.x, center.y ]
+        else
+          raise ArgumentError.new("Expected an Array or a Geos::Geometry for the origin")
+      end
+
+      self.affine!({
+        :afac => Math.cos(radians),
+        :bfac => -Math.sin(radians),
+        :cfac => 0,
+        :dfac => Math.sin(radians),
+        :efac => Math.cos(radians),
+        :ffac => 0,
+        :gfac => 0,
+        :hfac => 0,
+        :ifac => 1,
+        :xoff => origin[0] - Math.cos(radians) * origin[0] + Math.sin(radians) * origin[1],
+        :yoff => origin[1] - Math.sin(radians) * origin[0] - Math.cos(radians) * origin[1],
+        :zoff => 0
+      })
+    end
+
+    def rotate(radians, origin = [ 0.0, 0.0 ])
+      self.dup.rotate!(radians, origin)
+    end
+
+    def rotate_x!(radians)
+      self.affine!({
+        :afac => 1,
+        :bfac => 0,
+        :cfac => 0,
+        :dfac => 0,
+        :efac => Math.cos(radians),
+        :ffac => -Math.sin(radians),
+        :gfac => 0,
+        :hfac => Math.sin(radians),
+        :ifac => Math.cos(radians),
+        :xoff => 0,
+        :yoff => 0,
+        :zoff => 0
+      })
+    end
+
+    def rotate_x(radians)
+      self.dup.rotate_x!(radians)
+    end
+
+    def rotate_y!(radians)
+      self.affine!({
+        :afac => Math.cos(radians),
+        :bfac => 0,
+        :cfac => Math.sin(radians),
+        :dfac => 0,
+        :efac => 1,
+        :ffac => 0,
+        :gfac => -Math.sin(radians),
+        :hfac => 0,
+        :ifac => Math.cos(radians),
+        :xoff => 0,
+        :yoff => 0,
+        :zoff => 0
+      })
+    end
+
+    def rotate_y(radians)
+      self.dup.rotate_y!(radians)
+    end
+
+    def rotate_z!(radians)
+      self.rotate!(radians)
+    end
+
+    def rotate_z(radians)
+      self.dup.rotate!(radians)
+    end
+
+    def scale!(*args)
+      x, y, z = if args.length == 1 && args[0].is_a?(Hash)
+        args[0].values_at(:x, :y, :z)
+      elsif args.length.between?(1, 3)
+        args.values_at(0...3)
+      else
+        raise ArgumentError.new("Wrong number of arguments #{args.length} for 1-3")
+      end
+
+      self.affine!({
+        :afac => x || 1,
+        :bfac => 0,
+        :cfac => 0,
+        :dfac => 0,
+        :efac => y || 1,
+        :ffac => 0,
+        :gfac => 0,
+        :hfac => 0,
+        :ifac => z || 1,
+        :xoff => 0,
+        :yoff => 0,
+        :zoff => 0
+      })
+    end
+
+    def scale(*args)
+      self.dup.scale!(*args)
+    end
+
+    def trans_scale!(*args)
+      delta_x, delta_y, x_factor, y_factor = if args.length == 1 && args[0].is_a?(Hash)
+        args[0].values_at(:delta_x, :delta_y, :x_factor, :y_factor)
+      elsif args.length.between?(1, 4)
+        args.values_at(0...4)
+      else
+        raise ArgumentError.new("Wrong number of arguments #{args.length} for 1-4")
+      end
+
+      x_factor ||= 1
+      y_factor ||= 1
+      delta_x ||= 0
+      delta_y ||= 0
+
+      self.affine!({
+        :afac => x_factor,
+        :bfac => 0,
+        :cfac => 0,
+        :dfac => 0,
+        :efac => y_factor,
+        :ffac => 0,
+        :gfac => 0,
+        :hfac => 0,
+        :ifac => 1,
+        :xoff => delta_x * x_factor,
+        :yoff => delta_y * y_factor,
+        :zoff => 0
+      })
+    end
+
+    def trans_scale(*args)
+      self.dup.trans_scale!(*args)
+    end
+
+    def translate!(*args)
+      x, y, z = if args.length == 1 && args[0].is_a?(Hash)
+        args[0].values_at(:x, :y, :z)
+      elsif args.length.between?(1, 3)
+        args.values_at(0...3)
+      else
+        raise ArgumentError.new("Wrong number of arguments #{args.length} for 1-3")
+      end
+
+      self.affine!({
+        :afac => 1,
+        :bfac => 0,
+        :cfac => 0,
+        :dfac => 0,
+        :efac => 1,
+        :ffac => 0,
+        :gfac => 0,
+        :hfac => 0,
+        :ifac => 1,
+        :xoff => x || 0,
+        :yoff => y || 0,
+        :zoff => z || 1
+      })
+    end
+
+    def translate(*args)
+      self.dup.translate!(*args)
+    end
   end
 end
 

data/lib/geos/extensions/exceptions.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+# frozen_string_literal: true
 
 module Geos
   unless defined?(Geos::Error)

data/lib/geos/extensions/version.rb

@@ -1,7 +1,9 @@
+# encoding: UTF-8
+# frozen_string_literal: true
 
 module Geos
   module Extensions
-    VERSION = '1.0.0'.freeze
+    VERSION = '2.0.0'.freeze
   end
 end
 

data/lib/geos/geometry.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+# frozen_string_literal: true
 
 module Geos
   # This is our base module that we use for some generic methods used all
@@ -60,7 +62,7 @@ module Geos
         []
       end
 
-      ret = ''
+      ret = ''.dup
 
       if options[:include_srid]
         srid = if options[:srid]

data/lib/geos/geometry_collection.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+# frozen_string_literal: true
 
 module Geos
   class GeometryCollection
@@ -55,6 +57,56 @@ module Geos
       }
     end
     alias_method :to_geojsonable, :as_geojson
+
+    # Dumps points similarly to the PostGIS `ST_DumpPoints` function.
+    def dump_points(cur_path = [])
+      self.each do |geom|
+        cur_path << geom.dump_points
+      end
+      cur_path
+    end
+
+    %w{ x y z }.each do |dimension|
+      %w{ max min }.each do |op|
+        self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+          def #{dimension}_#{op}
+            unless self.empty?
+              self.collect(&:#{dimension}_#{op}).#{op}
+            end
+          end
+        EOF
+      end
+    end
+
+    %w{
+      affine
+      rotate
+      rotate_x
+      rotate_y
+      rotate_z
+      scale
+      snap_to_grid
+      trans_scale
+      translate
+    }.each do |m|
+      self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+        def #{m}!(*args)
+          unless self.empty?
+            self.num_geometries.times do |i|
+              self[i].#{m}!(*args)
+            end
+          end
+
+          self
+        end
+
+        def #{m}(*args)
+          ret = self.dup.#{m}!(*args)
+          ret.srid = pick_srid_according_to_policy(self.srid)
+          ret
+        end
+      EOF
+    end
   end
 end