postgis_adapter 0.1.8

data/lib/postgis_functions/linestring.rb

@@ -0,0 +1,172 @@
+module PostgisFunctions
+####
+###
+##
+#
+# LINESTRING
+#
+
+  module LineStringFunctions
+    
+    #
+    # Returns the 2D length of the geometry if it is a linestring, multilinestring,
+    # ST_Curve, ST_MultiCurve. 0 is returned for areal geometries. For areal geometries
+    # use 'perimeter'. Measurements are in the units of the spatial reference system
+    # of the geometry.
+    #
+    # Returns Float
+    #
+    def length
+      dis = postgis_calculate(:length, self).to_f
+    end
+
+    #
+    # Returns the 3-dimensional or 2-dimensional length of the geometry if it is
+    # a linestring or multi-linestring. For 2-d lines it will just return the 2-d
+    # length (same as 'length')
+    #
+    # Returns Float
+    #
+    def length_3d
+      dis = postgis_calculate(:length3d, self).to_f
+    end
+
+    #
+    # Calculates the length of a geometry on an ellipsoid. This is useful if the
+    # coordinates of the geometry are in longitude/latitude and a length is
+    # desired without reprojection. The ellipsoid is a separate database type and
+    # can be constructed as follows:
+    #
+    # SPHEROID[<NAME>,<SEMI-MAJOR AXIS>,<INVERSE FLATTENING>]
+    #
+    # Example:
+    #   SPHEROID["GRS_1980",6378137,298.257222101]
+    #
+    # Defaults to:
+    #
+    #   SPHEROID["IERS_2003",6378136.6,298.25642]
+    #
+    # Returns Float length_spheroid(geometry linestring, spheroid);
+    #
+    def length_spheroid(spheroid = EARTH_SPHEROID)
+      dis = postgis_calculate(:length_spheroid, self, spheroid).to_f
+    end
+
+    #
+    # Return the number of points of the geometry.
+    # PostGis ST_NumPoints does not work as nov/08
+    #
+    # Returns Integer ST_NPoints(geometry g1);
+    #
+    def num_points
+      postgis_calculate(:npoints, self).to_i
+    end
+
+    #
+    # Returns geometry start point.
+    #
+    def start_point
+      postgis_calculate(:startpoint, self)
+    end
+
+    #
+    # Returns geometry end point.
+    #
+    def end_point
+      postgis_calculate(:endpoint, self)
+    end
+
+    #
+    # Takes two geometry objects and returns TRUE if their intersection
+    # "spatially cross", that is, the geometries have some, but not all interior
+    # points in common. The intersection of the interiors of the geometries must
+    # not be the empty set and must have a dimensionality less than the the
+    # maximum dimension of the two input geometries. Additionally, the
+    # intersection of the two geometries must not equal either of the source
+    # geometries. Otherwise, it returns FALSE.
+    #
+    #
+    # Returns Boolean ST_Crosses(geometry g1, geometry g2);
+    #
+    def crosses? other
+      postgis_calculate(:crosses, [self, other])
+    end
+
+    #
+    # Returns a float between 0 and 1 representing the location of the closest point
+    # on LineString to the given Point, as a fraction of total 2d line length.
+    #
+    # You can use the returned location to extract a Point (ST_Line_Interpolate_Point)
+    # or a substring (ST_Line_Substring).
+    #
+    # This is useful for approximating numbers of addresses.
+    #
+    # Returns float (0 to 1) ST_Line_Locate_Point(geometry a_linestring, geometry a_point);
+    #
+    def locate_point point
+      postgis_calculate(:line_locate_point, [self, point]).to_f
+    end
+    
+    #
+    # Return a derived geometry collection value with elements that match the 
+    # specified measure. Polygonal elements are not supported.
+    #
+    # Semantic is specified by: ISO/IEC CD 13249-3:200x(E) - Text for 
+    # Continuation CD Editing Meeting
+    #
+    # Returns geometry ST_Locate_Along_Measure(geometry ageom_with_measure, float a_measure);
+    #
+    def locate_along_measure(measure)
+      postgis_calculate(:locate_along_measure, self, measure)
+    end
+    
+    #
+    # Return a derived geometry collection value with elements that match the 
+    # specified range of measures inclusively. Polygonal elements are not supported.
+    #
+    # Semantic is specified by: ISO/IEC CD 13249-3:200x(E) - Text for Continuation CD Editing Meeting
+    #
+    # Returns geometry ST_Locate_Between_Measures(geometry geomA, float measure_start, float measure_end);
+    #
+    def locate_between_measures(a, b)
+      postgis_calculate(:locate_between_measures, self, [a,b])
+    end
+    
+    #
+    # Returns a point interpolated along a line. First argument must be a LINESTRING.
+    # Second argument is a float8 between 0 and 1 representing fraction of total
+    # linestring length the point has to be located.
+    #
+    # See ST_Line_Locate_Point for computing the line location nearest to a Point.
+    #
+    # Returns geometry ST_Line_Interpolate_Point(geometry a_linestring, float a_fraction);
+    #
+    def interpolate_point(fraction)
+      postgis_calculate(:line_interpolate_point, self, fraction)
+    end
+
+    #
+    # Return a linestring being a substring of the input one starting and ending
+    # at the given fractions of total 2d length. Second and third arguments are
+    # float8 values between 0 and 1. This only works with LINESTRINGs. To use
+    # with contiguous MULTILINESTRINGs use in conjunction with ST_LineMerge.
+    #
+    # If 'start' and 'end' have the same value this is equivalent to 'interpolate_point'.
+    #
+    # See 'locate_point' for computing the line location nearest to a Point.
+    #
+    # Returns geometry ST_Line_Substring(geometry a_linestring, float startfraction, float endfraction);
+    #
+    def line_substring(s,e)
+      postgis_calculate(:line_substring, self, [s, e])
+    end
+
+    ###  
+    #Not implemented in postgis yet
+    # ST_max_distance Returns the largest distance between two line strings.
+    #def max_distance other
+    # #float ST_Max_Distance(geometry g1, geometry g2);
+    #  postgis_calculate(:max_distance, [self, other])
+    #end
+  end
+end

data/lib/postgis_functions/point.rb

@@ -0,0 +1,89 @@
+module PostgisFunctions
+  ####
+  ###
+  ##
+  #
+  # POINT
+  #
+  #
+  module PointFunctions
+
+    #
+    # Returns a float between 0 and 1 representing the location of the closest point
+    # on LineString to the given Point, as a fraction of total 2d line length.
+    #
+    # You can use the returned location to extract a Point (ST_Line_Interpolate_Point)
+    # or a substring (ST_Line_Substring).
+    #
+    # This is useful for approximating numbers of addresses.
+    #
+    # Returns float (0 to 1) ST_Line_Locate_Point(geometry a_linestring, geometry a_point);
+    #
+    def where_on_line line
+      postgis_calculate(:line_locate_point, [line, self]).to_f
+    end
+
+    #
+    # Linear distance in meters between two lon/lat points.
+    # Uses a spherical earth and radius of 6370986 meters.
+    # Faster than 'distance_spheroid', but less accurate.
+    #
+    # Only implemented for points.
+    #
+    # Returns Float ST_Distance_Sphere(geometry pointlonlatA, geometry pointlonlatB);
+    #
+    def distance_sphere_to(other)
+      dis = postgis_calculate(:distance_sphere, [self, other]).to_f
+    end
+
+    #
+    # Calculates the distance on an ellipsoid. This is useful if the
+    # coordinates of the geometry are in longitude/latitude and a length is
+    # desired without reprojection. The ellipsoid is a separate database type and
+    # can be constructed as follows:
+    #
+    # This is slower then 'distance_sphere_to', but more precise.
+    #
+    # SPHEROID[<NAME>,<SEMI-MAJOR AXIS>,<INVERSE FLATTENING>]
+    #
+    # Example:
+    #   SPHEROID["GRS_1980",6378137,298.257222101]
+    #
+    # Defaults to:
+    #
+    #   SPHEROID["IERS_2003",6378136.6,298.25642]
+    #
+    # Returns ST_Distance_Spheroid(geometry geomA, geometry geomB, spheroid);
+    #
+    def distance_spheroid_to(other, spheroid = EARTH_SPHEROID)
+      postgis_calculate(:distance_spheroid, [self, other], spheroid).to_f
+    end
+
+    #
+    # The azimuth of the segment defined by the given Point geometries,
+    # or NULL if the two points are coincident. Return value is in radians.
+    #
+    # The Azimuth is mathematical concept defined as the angle, in this case
+    # measured in radian, between a reference plane and a point.
+    #
+    # Returns Float ST_Azimuth(geometry pointA, geometry pointB);
+    #
+    def azimuth other
+      #TODO: return if not point/point
+      postgis_calculate(:azimuth, [self, other]).to_f
+      rescue
+        ActiveRecord::StatementInvalid
+    end
+
+    #
+    # True if the geometry is a point and is inside the circle.
+    #
+    # Returns Boolean ST_point_inside_circle(geometry, float, float, float)
+    #
+    def inside_circle?(x,y,r)
+      postgis_calculate(:point_inside_circle, self, [x,y,r])
+    end
+
+  end
+  
+end

data/lib/postgis_functions/polygon.rb

@@ -0,0 +1,78 @@
+module PostgisFunctions
+  ###
+  ##
+  #
+  # Polygon
+  #
+  #
+  module PolygonFunctions
+
+    #
+    # The area of the geometry if it is a polygon or multi-polygon.
+    # Return the area measurement of an ST_Surface or ST_MultiSurface value.
+    # Area is in the units of the spatial reference system.
+    #
+    # Returns Float ST_Area(geometry g1);
+    #
+    def area
+      postgis_calculate(:area, self).to_f
+    end
+
+    #
+    # Returns the 2D perimeter of the geometry if it is a ST_Surface, ST_MultiSurface
+    # (Polygon, Multipolygon). 0 is returned for non-areal geometries. For linestrings
+    # use 'length'. Measurements are in the units of the spatial reference system of
+    # the geometry.
+    #
+    # Returns Float ST_Perimeter(geometry g1);
+    #
+    def perimeter
+      postgis_calculate(:perimeter, self).to_f
+    end
+
+    #
+    # Returns the 3-dimensional perimeter of the geometry, if it is a polygon or multi-polygon.
+    # If the geometry is 2-dimensional, then the 2-dimensional perimeter is returned.
+    #
+    # Returns Float ST_Perimeter3D(geometry geomA);
+    #
+    def perimeter3d
+      postgis_calculate(:perimeter3d, self).to_f
+    end
+
+    #
+    # True if the LineString's start and end points are coincident.
+    #
+    # This method implements the OpenGIS Simple Features Implementation
+    # Specification for SQL.
+    #
+    # SQL-MM defines the result of ST_IsClosed(NULL) to be 0, while PostGIS returns NULL.
+    #
+    # Returns boolean ST_IsClosed(geometry g);
+    #
+    def closed?
+      postgis_calculate(:isclosed, self)
+    end
+    alias_method "is_closed?", "closed?"
+
+    #
+    # True if no point in Geometry B is outside Geometry A
+    #
+    # This function call will automatically include a bounding box comparison
+    # that will make use of any indexes that are available on the geometries.
+    # To avoid index use, use the function _ST_Covers.
+    #
+    # Do not call with a GEOMETRYCOLLECTION as an argument
+    # Do not use this function with invalid geometries. You will get unexpected results.
+    #
+    # Performed by the GEOS module.
+    #
+    # Returns Boolean ST_Covers(geometry geomA, geometry geomB);
+    #
+    def covers? other
+      postgis_calculate(:covers, [self, other])
+    end
+
+  end
+  
+end

data/postgis_adapter.gemspec

@@ -0,0 +1,38 @@
+Gem::Specification.new do |s|
+  s.name = "postgis_adapter"
+  s.version = "0.1.8"
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Marcos Piccinini"]
+  s.date = "2008-12-16"
+  s.description = "Postgis Adapter for Activer Record"
+  s.email = ["x@nofxx.com"]
+  s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.rdoc"]
+  s.files = ["History.txt", "MIT-LICENSE", "Manifest.txt", "README.rdoc", "Rakefile", "init.rb", "install.rb", "lib/postgis_adapter.rb", "lib/postgis_adapter/acts_as_geom.rb", "lib/postgis_adapter/common_spatial_adapter.rb", "lib/postgis_functions.rb", "lib/postgis_functions/bbox.rb", "lib/postgis_functions/class.rb", "lib/postgis_functions/common.rb", "lib/postgis_functions/linestring.rb", "lib/postgis_functions/point.rb", "lib/postgis_functions/polygon.rb", "postgis_adapter.gemspec", "rails/init.rb", "script/console", "script/destroy", "script/generate", "uninstall.rb"]
+  s.test_files = ["spec/acts_as_geom_spec.rb", "spec/common_spatial_adapter_spec.rb", "spec/db/database_postgis.yml", "spec/db/models_postgis.rb", "spec/db/schema_postgis.rb", "spec/postgis_adapter_spec.rb", "spec/postgis_functions/bbox_spec.rb", "spec/postgis_functions/linestring_spec.rb", "spec/postgis_functions/point_spec.rb", "spec/postgis_functions/polygon_spec.rb", "spec/postgis_functions_spec.rb", "spec/spec.opts", "spec/spec_helper.rb"]
+  s.has_rdoc = true
+  s.homepage = "http://github.com/nofxx/postgis_adapter"
+  s.rdoc_options = ["--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{postgis_adapter}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = "Postgis Adapter for Activer Record"
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activerecord>, [">= 2.0.2"])
+      s.add_development_dependency(%q<newgem>, [">= 1.1.0"])
+      s.add_development_dependency(%q<hoe>, [">= 1.8.0"])
+    else
+      s.add_dependency(%q<activerecord>, [">= 2.0.2"])
+      s.add_dependency(%q<newgem>, [">= 1.1.0"])
+      s.add_dependency(%q<hoe>, [">= 1.8.0"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, [">= 2.0.2"])
+    s.add_dependency(%q<newgem>, [">= 1.1.0"])
+    s.add_dependency(%q<hoe>, [">= 1.8.0"])
+  end
+end

data/rails/init.rb

@@ -0,0 +1,8 @@
+class SpatialAdapterNotCompatibleError < StandardError
+end
+
+unless ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
+  raise SpatialAdapterNotCompatibleError.
+    new("Only PostgreSQL with PostGIS is supported by the postgis adapter plugin.")
+end
+require 'postgis_adapter'

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/postgis_adapter.rb'}"
+puts "Loading postgis_adapter gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/spec/acts_as_geom_spec.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe "ActsAsGeom" do
+
+  before(:each) do
+    class City < ActiveRecord::Base
+      acts_as_geom :geom
+    end
+  end
+
+  it "should get the geom type" do
+    City.get_geom_type(:geom).should eql(:polygon)
+  end
+
+end