georuby 1.9.3

data/lib/geo_ruby/simple_features/helper.rb

@@ -0,0 +1,18 @@
+module GeoRuby
+  module SimpleFeatures
+    #indicates the presence of Z coordinates in EWKB strings
+    Z_MASK=0x80000000
+    #indicates the presence of M coordinates in EWKB strings.
+    M_MASK=0x40000000
+    #indicate the presence of a SRID in EWKB strings.
+    SRID_MASK=0x20000000
+    #GeoRSS namespace
+    GEORSS_NS = "http://www.georss.org/georss"
+    #GML Namespace
+    GML_NS = "http://www.opengis.net/gml"
+    #W3CGeo Namespace
+    W3CGEO_NS = "http://www.w3.org/2003/01/geo/wgs84_pos#"
+    #KML Namespace
+    KML_NS = "http://earth.google.com/kml/2.1"
+  end
+end

data/lib/geo_ruby/simple_features/line_string.rb

@@ -0,0 +1,228 @@
+require "geo_ruby/simple_features/geometry"
+
+module GeoRuby
+  module SimpleFeatures
+    #Represents a line string as an array of points (see Point).
+    class LineString < Geometry
+      #the list of points forming the line string
+      attr_reader :points
+
+      def initialize(srid= DEFAULT_SRID,with_z=false,with_m=false)
+        super(srid,with_z,with_m)
+        @points=[]
+      end
+
+      #Delegate the unknown methods to the points array
+      def method_missing(method_name,*args,&b)
+        @points.send(method_name,*args,&b)
+      end
+
+      #tests if the line string is closed
+      def is_closed
+        #a bit naive...
+        @points.first == @points.last
+      end
+      alias :closed? :is_closed
+
+      def clockwise?
+        tuples = @points.zip(
+          @points[1..-1] + [@points[0]],
+          @points[2..-1] + [@points[0], @points[1]])
+        tuples.map!{ |a,b,c| b.x * (c.y - a.y)  }
+        sum = tuples.inject(0.0){ |sum, elem| sum+elem }
+
+        sum < 0.0
+      end
+
+      #Bounding box in 2D/3D. Returns an array of 2 points
+      def bounding_box
+        max_x, min_x, max_y, min_y = -Float::MAX, Float::MAX, -Float::MAX, Float::MAX
+        if(with_z)
+          max_z, min_z = -Float::MAX,Float::MAX
+          each do |point|
+            max_y = point.y if point.y > max_y
+            min_y = point.y if point.y < min_y
+            max_x = point.x if point.x > max_x
+            min_x = point.x if point.x < min_x
+            max_z = point.z if point.z > max_z
+            min_z = point.z if point.z < min_z
+          end
+          [Point.from_x_y_z(min_x,min_y,min_z),Point.from_x_y_z(max_x,max_y,max_z)]
+        else
+          each do |point|
+            max_y = point.y if point.y > max_y
+            min_y = point.y if point.y < min_y
+            max_x = point.x if point.x > max_x
+            min_x = point.x if point.x < min_x
+          end
+          [Point.from_x_y(min_x,min_y),Point.from_x_y(max_x,max_y)]
+        end
+      end
+
+      def m_range
+        if with_m
+          max_m, min_m = -Float::MAX, Float::MAX
+          each do |point|
+            max_m = point.m if point.m > max_m
+            min_m = point.m if point.m < min_m
+          end
+          [min_m,max_m]
+        else
+          [0,0]
+        end
+      end
+
+     #call to native Geo intersect, return true or false
+      def intersects?(other_line_string)
+
+      end
+
+      def spherical_distance
+        total = 0
+        @points.each_with_index do |p,i|
+          total += p.spherical_distance(@points[i+1]) if @points[i+1]
+        end
+        total
+      end
+
+      def euclidian_distance
+        total = 0
+        @points.each_with_index do |p,i|
+          total += p.euclidian_distance(@points[i+1]) if @points[i+1]
+        end
+        total
+      end
+
+      #Tests the equality of line strings
+      def ==(other_line_string)
+        if(other_line_string.class != self.class or
+             other_line_string.length != self.length)
+          false
+        else
+          index=0
+          while index<length
+            return false if self[index] != other_line_string[index]
+            index+=1
+          end
+          true
+        end
+      end
+
+      #Binary representation of a line string
+      def binary_representation(allow_z=true,allow_m=true) #:nodoc:
+        rep = [length].pack("V")
+        each {|point| rep << point.binary_representation(allow_z,allow_m) }
+        rep
+      end
+
+      #WKB geometry type
+      def binary_geometry_type #:nodoc:
+        2
+      end
+
+      #Text representation of a line string
+      def text_representation(allow_z=true,allow_m=true) #:nodoc:
+        @points.collect{|point| point.text_representation(allow_z,allow_m) }.join(",")
+      end
+      #WKT geometry type
+      def text_geometry_type #:nodoc:
+        "LINESTRING"
+      end
+
+      #georss simple representation
+      def georss_simple_representation(options) #:nodoc:
+        georss_ns = options[:georss_ns] || "georss"
+        geom_attr = options[:geom_attr]
+        "<#{georss_ns}:line#{geom_attr}>" + georss_poslist + "</#{georss_ns}:line>\n"
+      end
+      #georss w3c representation : outputs the first point of the line
+      def georss_w3cgeo_representation(options) #:nodoc:
+        w3cgeo_ns = options[:w3cgeo_ns] || "geo"
+        "<#{w3cgeo_ns}:lat>#{self[0].y}</#{w3cgeo_ns}:lat>\n<#{w3cgeo_ns}:long>#{self[0].x}</#{w3cgeo_ns}:long>\n"
+      end
+      #georss gml representation
+      def georss_gml_representation(options) #:nodoc:
+        georss_ns = options[:georss_ns] || "georss"
+        gml_ns = options[:gml_ns] || "gml"
+
+        result = "<#{georss_ns}:where>\n<#{gml_ns}:LineString>\n<#{gml_ns}:posList>\n"
+        result += georss_poslist
+        result += "\n</#{gml_ns}:posList>\n</#{gml_ns}:LineString>\n</#{georss_ns}:where>\n"
+      end
+
+      def georss_poslist #:nodoc:
+        map {|point| "#{point.y} #{point.x}"}.join(" ")
+      end
+
+      #outputs the geometry in kml format : options are <tt>:id</tt>, <tt>:tesselate</tt>, <tt>:extrude</tt>,
+      #<tt>:altitude_mode</tt>. If the altitude_mode option is not present, the Z (if present) will not be output (since
+      #it won't be used by GE anyway: clampToGround is the default)
+      def kml_representation(options = {}) #:nodoc:
+        result = "<LineString#{options[:id_attr]}>\n"
+        result += options[:geom_data] if options[:geom_data]
+        result += "<coordinates>"
+        result += kml_poslist(options)
+        result += "</coordinates>\n"
+        result += "</LineString>\n"
+      end
+
+      def kml_poslist(options) #:nodoc:
+        pos_list = if options[:allow_z]
+           map {|point| "#{point.x},#{point.y},#{options[:fixed_z] || point.z || 0}" }
+        else
+          map {|point| "#{point.x},#{point.y}" }
+        end
+        pos_list.reverse! if(options[:reverse])
+        pos_list.join(" ")
+      end
+
+      # Simplify linestring (Douglas Peucker Algorithm)
+      # http://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm
+      def simplify(epsilon=1)
+        LineString.from_points(do_simplify(@points, epsilon))
+      end
+
+      def do_simplify(list, epsilon)
+        index = dmax = 0
+        2.upto(list.length - 1) do |i|
+          d = list[i].orthogonal_distance(list[0], list[-1])
+          index, dmax = i, d if d > dmax
+        end
+
+        if dmax >= epsilon
+          res1 = do_simplify(list[0..index], epsilon)
+          res2 = do_simplify(list[index..-1], epsilon)
+          res1[0..-2] + res2[0..-1]
+        else
+          [list[0], list[-1]]
+        end
+      end
+
+      def to_coordinates
+        points.map{|p| p.to_coordinates }
+      end
+
+      # simple geojson representation
+      # TODO add CRS / SRID support?
+      def to_json(options = {})
+        {:type => 'LineString',
+         :coordinates => self.to_coordinates}.to_json(options)
+      end
+      alias :as_geojson :to_json
+
+      #Creates a new line string. Accept an array of points as argument
+      def self.from_points(points,srid=DEFAULT_SRID,with_z=false,with_m=false)
+        line_string = new(srid,with_z,with_m)
+        line_string.concat(points)
+        line_string
+      end
+
+      #Creates a new line string. Accept a sequence of points as argument : ((x,y)...(x,y))
+      def self.from_coordinates(points,srid=DEFAULT_SRID,with_z=false,with_m=false)
+        line_string = new(srid,with_z,with_m)
+        line_string.concat( points.map {|p| Point.from_coordinates(p,srid,with_z,with_m) } )
+        line_string
+      end
+    end
+  end
+end

data/lib/geo_ruby/simple_features/linear_ring.rb

@@ -0,0 +1,34 @@
+require 'geo_ruby/simple_features/line_string'
+
+module GeoRuby
+
+  module SimpleFeatures
+
+    #Represents a linear ring, which is a closed line string (see LineString).
+    #Currently, no check is performed to verify if the linear ring is really closed.
+    class LinearRing < LineString
+
+      def initialize(srid= DEFAULT_SRID,with_z=false,with_m=false)
+        super(srid,with_z,with_m)
+      end
+
+
+    # Does this linear string contain the given point?  We use the
+    # algorithm described here:
+    #
+    # http://www.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html
+    def contains_point?(point)
+      x, y = point.x, point.y
+      tuples = @points.zip(@points[1..-1] + [@points[0]])
+      crossings =
+        tuples.select do |a, b|
+          (b.y > y != a.y > y) && (x < (a.x - b.x) * (y - b.y) / (a.y - b.y) + b.x)
+        end
+
+      crossings.size % 2 == 1
+    end
+    end
+
+  end
+
+end

data/lib/geo_ruby/simple_features/multi_line_string.rb

@@ -0,0 +1,63 @@
+require 'geo_ruby/simple_features/geometry_collection'
+
+module GeoRuby
+
+  module SimpleFeatures
+
+    #Represents a group of line strings (see LineString).
+    class MultiLineString < GeometryCollection
+
+      def initialize(srid = DEFAULT_SRID,with_z=false,with_m=false)
+        super(srid)
+      end
+
+      def binary_geometry_type #:nodoc:
+        5
+      end
+
+      def points
+        geometries.map(&:points).flatten
+      end
+
+      #Text representation of a multi line string
+      def text_representation(allow_z=true,allow_m=true) #:nodoc:
+        @geometries.collect{|line_string| "(" + line_string.text_representation(allow_z,allow_m) + ")" }.join(",")
+      end
+
+      #WKT geometry type
+      def text_geometry_type #:nodoc:
+        "MULTILINESTRING"
+      end
+
+      def to_line_string(join = true)
+        LineString.from_points(points)
+      end
+      
+      def to_coordinates
+        geometries.map{|ls| ls.to_coordinates}
+      end
+
+      # simple geojson representation
+      # TODO add CRS / SRID support?
+      def to_json(options = {})
+        {:type => 'MultiLineString',
+         :coordinates => self.to_coordinates}.to_json(options)
+      end
+      alias :as_geojson :to_json
+      
+      #Creates a new multi line string from an array of line strings
+      def self.from_line_strings(line_strings,srid=DEFAULT_SRID,with_z=false,with_m=false)
+        multi_line_string = new(srid,with_z,with_m)
+        multi_line_string.concat(line_strings)
+        multi_line_string
+      end
+
+      #Creates a new multi line string from sequences of points : (((x,y)...(x,y)),((x,y)...(x,y)))
+      def self.from_coordinates(point_sequences,srid=DEFAULT_SRID,with_z=false,with_m=false)
+        multi_line_string = new(srid,with_z,with_m)
+        multi_line_string.concat(point_sequences.collect {|points| LineString.from_coordinates(points,srid,with_z,with_m) })
+        multi_line_string
+      end
+    end
+  end
+end

data/lib/geo_ruby/simple_features/multi_point.rb

@@ -0,0 +1,58 @@
+require 'geo_ruby/simple_features/geometry_collection'
+
+module GeoRuby
+  module SimpleFeatures
+    #Represents a group of points (see Point).
+    class MultiPoint < GeometryCollection
+
+      def initialize(srid= DEFAULT_SRID,with_z=false,with_m=false)
+        super(srid,with_z,with_m)
+      end
+
+      def binary_geometry_type #:nodoc:
+        4
+      end
+
+      def points
+        @geometries
+      end
+
+      #Text representation of a MultiPoint
+      def text_representation(allow_z=true,allow_m=true) #:nodoc:
+        "(" + @geometries.collect{|point| point.text_representation(allow_z,allow_m)}.join("),(") + ")"
+      end
+
+      #WKT geoemtry type
+      def text_geometry_type #:nodoc:
+        "MULTIPOINT"
+      end
+
+      def to_coordinates
+        points.map{|p| p.to_coordinates }
+      end
+
+      # simple geojson representation
+      # TODO add CRS / SRID support?
+      def to_json(options = {})
+        {:type => 'MultiPoint',
+         :coordinates => self.to_coordinates}.to_json(options)
+      end
+      alias :as_geojson :to_json
+
+      #Creates a new multi point from an array of points
+      def self.from_points(points,srid= DEFAULT_SRID,with_z=false,with_m=false)
+        multi_point= new(srid,with_z,with_m)
+        multi_point.concat(points)
+        multi_point
+      end
+
+      #Creates a new multi point from a list of point coordinates : ((x,y)...(x,y))
+      def self.from_coordinates(points,srid= DEFAULT_SRID,with_z=false,with_m=false)
+        multi_point= new(srid,with_z,with_m)
+        multi_point.concat(points.collect {|point| Point.from_coordinates(point,srid,with_z,with_m)})
+        multi_point
+      end
+
+    end
+  end
+end

data/lib/geo_ruby/simple_features/multi_polygon.rb

@@ -0,0 +1,64 @@
+require 'geo_ruby/simple_features/geometry_collection'
+
+module GeoRuby
+
+  module SimpleFeatures
+
+    #Represents a group of polygons (see Polygon).
+    class MultiPolygon < GeometryCollection
+
+      def initialize(srid = DEFAULT_SRID,with_z=false,with_m=false)
+        super(srid)
+      end
+
+      def binary_geometry_type #:nodoc:
+        6
+      end
+
+      def points
+        @points ||= geometries.inject([]) do |arr, r|
+          arr.concat(r.rings.map(&:points).flatten)
+        end
+      end
+
+      #Text representation of a MultiPolygon
+      def text_representation(allow_z=true,allow_m=true) #:nodoc:
+        @geometries.map {|polygon| "(" + polygon.text_representation(allow_z,allow_m) + ")"}.join(",")
+      end
+
+      #WKT geometry type
+      def text_geometry_type #:nodoc:
+        "MULTIPOLYGON"
+      end
+
+      def to_coordinates
+        geometries.map{|polygon| polygon.to_coordinates}
+      end
+
+      # simple geojson representation
+      # TODO add CRS / SRID support?
+      def to_json(options = {})
+        {:type => 'MultiPolygon',
+         :coordinates => self.to_coordinates}.to_json(options)
+      end
+      alias :as_geojson :to_json
+
+      #Creates a multi polygon from an array of polygons
+      def self.from_polygons(polygons,srid=DEFAULT_SRID,with_z=false,with_m=false)
+        multi_polygon = new(srid,with_z,with_m)
+        multi_polygon.concat(polygons)
+        multi_polygon
+      end
+
+      #Creates a multi polygon from sequences of points : ((((x,y)...(x,y)),((x,y)...(x,y)),((x,y)...(x,y)))
+      def self.from_coordinates(point_sequence_sequences,srid= DEFAULT_SRID,with_z=false,with_m=false)
+        multi_polygon = new(srid,with_z,with_m)
+        multi_polygon.concat( point_sequence_sequences.collect {|point_sequences| Polygon.from_coordinates(point_sequences,srid,with_z,with_m) } )
+        multi_polygon
+      end
+
+    end
+
+  end
+
+end