geoscript 0.1.0.pre-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 445d8baccf38f5d7554210741b7c0ea4c7d82a12
+  data.tar.gz: a725311f99daa2b3c18bade8dc85b4e316d8fb3c
+SHA512:
+  metadata.gz: 6864c3bfc0e262ec1b4deda2de33b426bc2d3f4923d47ee71ba6ce811d388deb5be32fb6d90be976e3bf506bfbb811979f633048671b9cca569a3101453a9351
+  data.tar.gz: 506594ffbc7bbc166dc05bfdd9bdf34fc921b58f6b2bd975b3770e33e59f451130df33787043930c93893d50c90e14774ab82fad5b0580c91766f16fbff86c29

data/README.md

@@ -0,0 +1,35 @@
+geoscript-ruby
+
+GeoScript for JRuby
+
+If in development, run `mvn install` to get GeoTools dependencies
+
+```ruby
+# installed gem
+# %> geoscript
+
+# development
+# %> rake console
+# or
+# %> bin/geoscript
+
+require 'geoscript'
+# => true
+include GeoScript::Geom
+# => Object
+
+p = Point.new -111.0, 45.7
+# => #<GeoScript::Geom::Point:0x636c4fcb>
+p.to_wkt
+# => "POINT (-111 45.7)"
+
+p2 = GeoScript::Projection.reproject p, 'epsg:4326', 'epsg:26912'
+# => #<GeoScript::Geom::Point:0x6a55c240>
+p2.to_wkt
+# => "POINT (500000 5060716.313515949)"
+
+poly = p2.buffer 100
+# => #<GeoScript::Geom::Polygon:0x7b32aba9>
+poly.get_area
+# => 31214.451522458345
+```

data/lib/geoscript.rb

@@ -0,0 +1,38 @@
+$: << File.expand_path(File.dirname(__FILE__))
+$: << File.expand_path(File.join(File.dirname(__FILE__), 'geoscript'))
+
+if defined? JRUBY_VERSION
+  require 'geotools-jars'
+
+  require 'geoscript/version'
+  require 'geoscript/util'
+  require 'geoscript/io'
+  require 'geoscript/projection'
+  require 'geoscript/geom'
+  require 'geoscript/feature'
+  require 'geoscript/datastore'
+  require 'geoscript/workspace'
+else
+  abort "GeoScript requires JRuby (http://jruby.org)"
+end
+
+java_import org.geotools.factory.Hints
+
+unless java.lang.System.get_property('org.geotools.referencing.forceXY') == 'true'
+  java.lang.System.set_property 'org.geotools.referencing.forceXY', 'true'
+end
+
+Hints.put_system_default Hints::FORCE_LONGITUDE_FIRST_AXIS_ORDER, java.lang.Boolean.new(true)
+
+module GeoScript
+  class << self
+    def version
+      VERSION
+    end
+
+    def geotools_version
+      ::Java::OrgGeotoolsFactory::GeoTools.version.to_string
+    end
+    alias_method :gt_version, :geotools_version
+  end
+end

data/lib/geoscript/datastore.rb

@@ -0,0 +1 @@
+require 'datastore/memory'

data/lib/geoscript/datastore/memory.rb

@@ -0,0 +1,11 @@
+java_import org.geotools.data.memory.MemoryDataStore
+
+module GeoScript
+  module DataStore
+    class Memory < MemoryDataStore
+      def initialize(params)
+        super()
+      end
+    end
+  end
+end

data/lib/geoscript/feature.rb

@@ -0,0 +1,3 @@
+require 'feature/field'
+require 'feature/schema'
+require 'feature/feature'

data/lib/geoscript/feature/feature.rb

@@ -0,0 +1,63 @@
+java_import org.geotools.feature.simple.SimpleFeatureBuilder
+ogFeature = org.opengis.feature.Feature
+
+module GeoScript
+  class Feature
+    def initialize(attrs=nil, id=nil, schema=nil)
+      raise 'No attributes specified for feature' unless attrs
+
+      unless attrs.kind_of? GeoScript::Feature
+        unless schema
+          if attrs.instance_of? Hash
+            schema_attrs = []
+            attrs.each do |k, v|
+              schema_attrs << {name: k.to_s, type: v.to_java.java_class}
+            end
+            @schema = GeoScript::Schema.new('feature', schema_attrs)
+          elsif attrs.instance_of? Array
+            raise 'Attributes may only be given as Array if schema is specified'
+          end
+        else
+          @schema = schema
+        end
+
+        if attrs.instance_of? Array
+          attrs_hash = {}
+          attrs.each_with_index {|v, i| attrs_hash[@schema.fields[i].name] = v}
+          attrs = attrs_hash
+        end
+
+        sfb = SimpleFeatureBuilder.new @schema.feature_type
+        attrs.each {|k, v| sfb.set(k.to_s, v)}
+        @feature = sfb.build_feature id
+      else
+        @feature = attrs
+        @schema = schema ? schema : GeoScript::Schema.new(@feature.feature_type)
+      end
+    end
+
+    def id
+      @feature.identifier.to_s
+    end
+
+    def get_geom
+      @feature.default_geometry
+    end
+    alias_method :geom, :get_geom
+
+    def set_geom(geom)
+      @feature.default_geometry = geom
+    end
+
+    def get_attributes
+      attributes = {}
+
+      @schema.fields.each do |field|
+        attributes[field] = @feature.get_attribute(field)
+      end
+
+      attributes
+    end
+    alias_method :attributes, :get_attributes
+  end
+end

data/lib/geoscript/feature/field.rb

@@ -0,0 +1,19 @@
+module GeoScript
+  class Field
+    attr_accessor :name, :type, :proj
+
+    def initialize(name, type, proj=nil)
+      @name = name
+      @type = type
+      @proj = proj
+    end
+
+    def to_s
+      "#{@name}: #{@type}"
+    end
+
+    def ==(other)
+      other.name == @name && other.type == @type && other.proj == @proj
+    end
+  end
+end

data/lib/geoscript/feature/schema.rb

@@ -0,0 +1,95 @@
+java_import org.opengis.feature.type.FeatureType
+java_import org.opengis.feature.type.GeometryDescriptor
+java_import org.geotools.feature.NameImpl
+java_import org.geotools.feature.simple.SimpleFeatureTypeBuilder
+
+module GeoScript
+  class Schema
+    attr_accessor :feature_type
+
+    def initialize(name=nil, fields=[], type=nil, uri='http://geoscript.org/feature')
+      if name && !fields.empty?
+        type_builder = SimpleFeatureTypeBuilder.new
+        type_builder.set_name NameImpl.new(name)
+        type_builder.setNamespaceURI uri
+        fields.each do |field|
+          if field.instance_of? GeoScript::Field
+            name, type, proj = field.name, field.type, field.proj
+          elsif field.instance_of? Hash
+            if field[:name] && field[:type]
+              name, type = field[:name], field[:type]
+            else
+              name, type = field.keys.first, field.values.first
+            end
+
+            if type.name.match /GeoScript::Geom/
+              proj = GeoScript::Projection.new(field[:proj]) if field[:proj]
+            end
+          elsif field.instance_of? Array
+            name, type = field[0], field[1]
+
+            if type.name.match /GeoScript::Geom/
+              proj = GeoScript::Projection.new(field[2]) if field[2]
+            end
+          end
+          type_builder.crs proj if proj
+
+          if type.name.match /GeoScript::Geom/
+            type = type.superclass.java_class
+          else
+            type = type.to_java.java_class
+          end
+
+          type_builder.add name, type
+        end
+        @feature_type = type_builder.build_feature_type
+      else
+        if !name && fields.empty?
+          raise "No name specified & No fields specified for type: #{type}"
+        elsif fields.empty?
+          raise "No fields specified for type: #{type}" if fields.empty?
+        elsif !name
+          raise 'No name specified'
+        end
+      end
+    end
+
+    def get_name
+      @feature_type.name.local_part
+    end
+    alias_method :name, :get_name
+
+    def get_geom
+      @feature_type.geometry_descriptor.local_name
+    end
+    alias_method :geom, :get_geom
+
+    def uri
+      @feature_type.name.namespaceURI
+    end
+
+    def get_proj
+      crs = @feature_type.coordinate_reference_system
+      GeoScript::Projection.new crs if crs
+    end
+    alias_method :proj, :get_proj
+
+    def get_fields
+      fields = []
+
+      @feature_type.attribute_descriptors.each do |ad|
+        fields << self.get(ad.local_name)
+      end
+
+      fields
+    end
+    alias_method :fields, :get_fields
+
+    def get(name)
+      ad = @feature_type.get_descriptor name
+      GeoScript::Field.new(ad.local_name, ad.type.binding, ad.coordinate_reference_system)
+    rescue NoMethodError
+      return nil
+    end
+  end
+end

data/lib/geoscript/geom.rb

@@ -0,0 +1,9 @@
+require 'geom/geom'
+require 'geom/bounds'
+require 'geom/point'
+require 'geom/multipoint'
+require 'geom/linestring'
+require 'geom/multilinestring'
+require 'geom/linearring'
+require 'geom/polygon'
+require 'geom/multipolygon'

data/lib/geoscript/geom/bounds.rb

@@ -0,0 +1,84 @@
+module GeoScript
+  module Geom
+    java_import com.vividsolutions.jts.geom.Envelope
+    java_import org.geotools.geometry.jts.ReferencedEnvelope
+
+    class Bounds < ReferencedEnvelope
+      include GeoScript::Geom
+
+      def initialize(env, proj = nil)
+        projection = GeoScript::Projection.new proj if proj
+
+        if env.kind_of? Envelope
+          if projection
+            super(env, projection)
+          elsif env.respond_to? :crs
+            if env.crs
+              super(env, env.crs)
+            else
+              super(env, nil)
+            end
+          else
+            super(env, nil)
+          end
+        else
+          if env.kind_of? Hash
+            if projection
+              super(env[:x_min], env[:x_max], env[:y_min], env[:y_max], projection)
+            else
+              super(env[:x_min], env[:x_max], env[:y_min], env[:y_max], nil)
+            end
+          elsif env.kind_of? Array
+            if projection
+              super(env[0], env[1], env[2], env[3], projection)
+            else
+              super(env[0], env[1], env[2], env[3])
+            end
+          else
+            super()
+          end
+        end
+      end
+
+      def get_west
+        self.min_x
+      end
+
+      def get_south
+        self.min_y
+      end
+
+      def get_east
+        self.max_x
+      end
+
+      def get_north
+        self.max_y
+      end
+
+      def get_projection
+        crs = self.coordinate_reference_system
+        GeoScript::Projection.new crs if crs
+      end
+
+      def get_aspect
+        self.width / self.height
+      end
+
+      def scale(factor)
+        width = self.width * (factor - 1) / 2
+        height = self.height * (factor - 1) / 2
+
+        Bounds.new self.west - width, self.south - height, self.east + width, self.north + height
+      end
+
+      def expand(other)
+        self.expand_to_include(other)
+      end
+
+      def to_polygon;end
+
+      def tile(resolution);end
+    end
+  end
+end

data/lib/geoscript/geom/geom.rb

@@ -0,0 +1,56 @@
+module GeoScript
+  module Geom
+    java_import java.awt.geom.AffineTransform
+    java_import com.vividsolutions.jts.geom.GeometryFactory
+    java_import com.vividsolutions.jts.geom.Geometry
+    java_import com.vividsolutions.jts.geom.prep.PreparedGeometryFactory
+    java_import com.vividsolutions.jts.simplify.DouglasPeuckerSimplifier
+    java_import com.vividsolutions.jts.triangulate.DelaunayTriangulationBuilder
+    java_import com.vividsolutions.jts.triangulate.VoronoiDiagramBuilder
+    java_import com.vividsolutions.jts.operation.buffer.BufferParameters
+    java_import com.vividsolutions.jts.operation.buffer.BufferOp
+    java_import org.geotools.geometry.jts.JTS
+    java_import org.geotools.referencing.operation.transform.AffineTransform2D
+
+    GEOM_FACTORY = GeometryFactory.new
+    PREP_FACTORY = PreparedGeometryFactory.new
+
+    def self.prepare(geom)
+      PREP_FACTORY.create(geom)
+    end
+
+    def self.simplify(geom, tolerance)
+      DouglasPeuckerSimplifier.simplify(geom, tolerance)
+    end
+
+    def self.buffer(geom, distance, single_sided = false)
+      buffer_params = BufferParameters.new
+      buffer_params.set_single_sided(single_sided)
+      BufferOp.buffer_op(geom, distance, buffer_params)
+    end
+
+    def self.get_bounds(geom)
+      Bounds.new geom.get_envelope_internal
+    end
+
+    def self.enhance(geom)
+      geom.bounds = get_bounds(geom)
+    end
+
+    def self.to_geoscript_geom(geom)
+      const_get(geom.geometry_type).new(geom)
+    end
+
+    def self.from_json(json)
+      to_geoscript_geom(GeoScript::IO::Geom.read_json(json))
+    end
+
+    def self.from_wkt(wkt)
+      to_geoscript_geom(GeoScript::IO::Geom.read_wkt(wkt))
+    end
+
+    def self.from_wkb(wkb)
+      to_geoscript_geom(GeoScript::IO::Geom.read_wkb(wkb))
+    end
+  end
+end

data/lib/geoscript/geom/linearring.rb

@@ -0,0 +1,37 @@
+module GeoScript
+  module Geom
+    java_import com.vividsolutions.jts.geom.Coordinate
+    JTSLinearRing = com.vividsolutions.jts.geom.LinearRing
+
+    class LinearRing < JTSLinearRing
+      include GeoScript::Geom
+
+      attr_accessor :bounds
+
+      def initialize(*coords)
+        if coords.size == 1
+          super(coords.first.coordinate_sequence) if coords.first.kind_of? LinearRing
+        else
+          line_string = LineString.new *coords
+          super(line_string.coordinate_sequence, GEOM_FACTORY)
+        end
+      end
+
+      def buffer(dist)
+        Polygon.new super
+      end
+
+      def to_wkt
+        GeoScript::IO::Geom.write_wkt self
+      end
+
+      def to_wkb
+        GeoScript::IO::Geom.write_wkb self
+      end
+
+      def to_json
+        GeoScript::IO::Geom.write_json self
+      end
+    end
+  end
+end

data/lib/geoscript/geom/linestring.rb

@@ -0,0 +1,62 @@
+module GeoScript
+  module Geom
+    java_import com.vividsolutions.jts.geom.Coordinate
+    JTSLineString = com.vividsolutions.jts.geom.LineString
+
+    class LineString < JTSLineString
+      include GeoScript::Geom
+
+      attr_accessor :bounds
+
+      def initialize(*coords)
+        if coords.size == 1
+          if coords.first.kind_of? JTSLineString
+            ls = coords.first
+          elsif coords.kind_of? Array
+            if coords.first.kind_of? Array
+              l = []
+              coords.first.each do |coord|
+                l << Coordinate.new(coord[0], coord[1])
+                l.last.z = coord[2] if coord[2]
+              end
+              if l.size > 0
+                ls = GEOM_FACTORY.create_line_string l.to_java(com.vividsolutions.jts.geom.Coordinate)
+              end
+            end
+          end
+        else
+          l = []
+          coords.each do |coord|
+            l << Coordinate.new(coord[0], coord[1])
+            l.last.z = coord[2] if coord[2]
+          end
+          if l.size > 0
+            ls = GEOM_FACTORY.create_line_string l.to_java(com.vividsolutions.jts.geom.Coordinate)
+          end
+        end
+
+        if ls
+          super(ls.coordinate_sequence, GEOM_FACTORY)
+        else
+          raise 'LineString could not be created. Check inputs.'
+        end
+      end
+
+      def buffer(dist)
+        Polygon.new super
+      end
+
+      def to_wkt
+        GeoScript::IO::Geom.write_wkt self
+      end
+
+      def to_wkb
+        GeoScript::IO::Geom.write_wkb self
+      end
+
+      def to_json
+        GeoScript::IO::Geom.write_json self
+      end
+    end
+  end
+end

data/lib/geoscript/geom/multilinestring.rb

@@ -0,0 +1,49 @@
+module GeoScript
+  module Geom
+    JTSMultiLineString = com.vividsolutions.jts.geom.MultiLineString
+
+    class MultiLineString < JTSMultiLineString
+      include GeoScript::Geom
+
+      attr_accessor :bounds
+
+      def initialize(*line_strings)
+        strings = []
+
+        if line_strings.first.kind_of? JTSMultiLineString
+          multi_line_string_geom = line_strings.first
+
+          for i in (0...multi_line_string_geom.num_geometries)
+            strings << multi_line_string_geom.get_geometry_n(i)
+          end
+        else
+          line_strings.each do |line_string|
+            if line_string.kind_of? LineString
+              strings << line_string
+            else
+              strings << LineString.new(*line_string)
+            end
+          end
+        end
+
+        super(strings.to_java(com.vividsolutions.jts.geom.LineString), GEOM_FACTORY)
+      end
+
+      def buffer(dist)
+        Polygon.new super
+      end
+
+      def to_wkt
+        GeoScript::IO::Geom.write_wkt self
+      end
+
+      def to_wkb
+        GeoScript::IO::Geom.write_wkb self
+      end
+
+      def to_json
+        GeoScript::IO::Geom.write_json self
+      end
+    end
+  end
+end

data/lib/geoscript/geom/multipoint.rb

@@ -0,0 +1,49 @@
+module GeoScript
+  module Geom
+    JTSMultiPoint = com.vividsolutions.jts.geom.MultiPoint
+    
+    class MultiPoint < JTSMultiPoint
+      include GeoScript::Geom
+
+      attr_accessor :bounds
+
+      def initialize(*points)
+        feature_points = []
+
+        if points.first.kind_of? JTSMultiPoint
+          mp_geom = points.first
+
+          for i in (0...mp_geom.num_geometries)
+            feature_points << mp_geom.get_geometry_n(i)
+          end
+        else
+          points.each do |point|
+            if point.kind_of? Point
+              feature_points << point
+            else
+              feature_points << Point.new(*point)
+            end
+          end
+        end
+
+        super(feature_points.to_java(com.vividsolutions.jts.geom.Point), GEOM_FACTORY)
+      end
+
+      def buffer(dist)
+        Polygon.new super
+      end
+
+      def to_wkt
+        GeoScript::IO::Geom.write_wkt self
+      end
+
+      def to_wkb
+        GeoScript::IO::Geom.write_wkb self
+      end
+
+      def to_json
+        GeoScript::IO::Geom.write_json self
+      end
+    end
+  end
+end

data/lib/geoscript/geom/multipolygon.rb

@@ -0,0 +1,47 @@
+module GeoScript
+  module Geom
+    JTSMultiPolygon = com.vividsolutions.jts.geom.MultiPolygon
+    
+    class MultiPolygon < JTSMultiPolygon
+      include GeoScript::Geom
+
+      attr_accessor :bounds
+
+      def initialize(*polygons)
+        polys = []
+
+        if polygons.first.kind_of? JTSMultiPolygon
+          multi_polygon = polygons.first
+          for i in range(0...multi_polygon.num_geometries)
+            polys << multi_polygon.get_geometry_n(i)
+          end
+        else
+          polygons.each do |polygon|
+            if polygon.kind_of? Java::ComVividsolutionsJtsGeom::Polygon
+              polys << polygon
+            else
+              polys << Polygon.new(*polygon)
+            end
+          end
+        end
+        super(polys.to_java(com.vividsolutions.jts.geom.Polygon), GEOM_FACTORY)
+      end
+
+      def buffer(dist)
+        Polygon.new super
+      end
+
+      def to_wkt
+        GeoScript::IO::Geom.write_wkt self
+      end
+
+      def to_wkb
+        GeoScript::IO::Geom.write_wkb self
+      end
+
+      def to_json
+        GeoScript::IO::Geom.write_json self
+      end
+    end
+  end
+end

data/lib/geoscript/geom/point.rb

@@ -0,0 +1,44 @@
+module GeoScript
+  module Geom
+    java_import com.vividsolutions.jts.geom.Coordinate
+    JTSPoint = com.vividsolutions.jts.geom.Point
+
+    class Point < JTSPoint
+      include GeoScript::Geom
+
+      attr_accessor :bounds
+
+      def initialize(*coords)
+        if coords.first.kind_of? JTSPoint
+          p = coords.first
+        else
+          if coords.empty?
+            c = Coordinate.new 0, 0
+          else
+            c = Coordinate.new coords[0], coords[1]
+            c.z = coords[2] if coords[2]
+          end
+          
+          p = GEOM_FACTORY.create_point c
+        end
+        super p.coordinate_sequence, GEOM_FACTORY
+      end
+
+      def buffer(dist)
+        Polygon.new super
+      end
+
+      def to_wkt
+        GeoScript::IO::Geom.write_wkt self
+      end
+
+      def to_wkb
+        GeoScript::IO::Geom.write_wkb self
+      end
+
+      def to_json
+        GeoScript::IO::Geom.write_json self
+      end
+    end
+  end
+end

data/lib/geoscript/geom/polygon.rb

@@ -0,0 +1,56 @@
+module GeoScript
+  module Geom
+    JTSPolygon = com.vividsolutions.jts.geom.Polygon
+
+    class Polygon < JTSPolygon
+      include GeoScript::Geom
+
+      attr_accessor :bounds
+
+      def initialize(*rings)
+        if rings.first.kind_of? JTSPolygon
+          interior_rings = []
+          num_rings = rings.first.num_interior_ring
+          for i in (0...num_rings)
+            interior_rings << rings.first.get_interior_ring_n(i)
+          end
+          shell = rings.first.exterior_ring
+          holes = interior_rings.to_java(com.vividsolutions.jts.geom.LinearRing)
+        else
+          linear_rings = []
+          rings.each do |ring|
+            if ring.kind_of? LinearRing
+              linear_rings << ring
+            else
+              linear_rings << LinearRing.new(*ring)
+            end
+          end
+
+          shell = linear_rings.first
+          holes = linear_rings[1..linear_rings.size].to_java(com.vividsolutions.jts.geom.LinearRing)
+        end
+        super(shell, holes, GEOM_FACTORY)
+      end
+
+      def buffer(dist)
+        Polygon.new super
+      end
+
+      def to_wkt
+        GeoScript::IO::Geom.write_wkt self
+      end
+
+      def to_wkb
+        GeoScript::IO::Geom.write_wkb self
+      end
+
+      def to_json
+        GeoScript::IO::Geom.write_json self
+      end
+
+      def bounds
+        Bounds.new self.get_envelope_internal
+      end
+    end
+  end
+end

data/lib/geoscript/io.rb

@@ -0,0 +1,4 @@
+require 'io/geom/json'
+require 'io/geom/wkb'
+require 'io/geom/wkt'
+require 'io/feature/json'

data/lib/geoscript/io/feature/json.rb

@@ -0,0 +1,15 @@
+java_import org.geotools.geojson.feature.FeatureJSON
+
+module GeoScript
+  module IO
+    module Feature
+      def self.write_json(feature)
+        FeatureJSON.new.to_string feature
+      end
+
+      def self.read_json(json)
+        GeoScript::Feature.new(FeatureJSON.new.read_feature(json))
+      end
+    end
+  end
+end

data/lib/geoscript/io/geom/json.rb

@@ -0,0 +1,15 @@
+java_import org.geotools.geojson.geom.GeometryJSON
+
+module GeoScript
+  module IO
+    module Geom
+      def self.write_json(geom)
+        GeometryJSON.new.to_string geom
+      end
+
+      def self.read_json(json)
+        GeometryJSON.new.read json.to_java
+      end
+    end
+  end
+end

data/lib/geoscript/io/geom/wkb.rb

@@ -0,0 +1,27 @@
+java_import com.vividsolutions.jts.io.WKBReader
+java_import com.vividsolutions.jts.io.WKBWriter
+
+module GeoScript
+  module IO
+    module Geom
+      include GeoScript::Util
+
+      def self.write_wkb(geom)
+        wkb = WKBWriter.new.write geom
+        WKBWriter.bytes_to_hex wkb
+      end
+
+      def self.read_wkb(wkb)
+        if wkb.kind_of? String
+          wkb = WKBReader.hex_to_bytes wkb
+        elsif wkb.kind_of? Array
+          # .to_java(java.lang.Byte) does not seem to work
+          # this is very hacky
+          wkb = WKBWriter.bytes_to_hex wkb
+          wkb = WKBReader.hex_to_bytes wkb
+        end
+        WKBReader.new.read wkb
+      end
+    end
+  end
+end

data/lib/geoscript/io/geom/wkt.rb

@@ -0,0 +1,16 @@
+java_import com.vividsolutions.jts.io.WKTReader
+java_import com.vividsolutions.jts.io.WKTWriter
+
+module GeoScript
+  module IO
+    module Geom
+      def self.read_wkt(wkt)
+        WKTReader.new.read wkt
+      end
+
+      def self.write_wkt(geom)
+        WKTWriter.new.write geom
+      end
+    end
+  end
+end

data/lib/geoscript/projection.rb

@@ -0,0 +1,84 @@
+java_import org.geotools.geometry.jts.GeometryCoordinateSequenceTransformer
+java_import org.geotools.referencing.CRS
+java_import org.opengis.referencing.crs.CoordinateReferenceSystem
+java_import org.geotools.factory.Hints
+
+module GeoScript
+  class Projection
+    attr_accessor :crs
+
+    def initialize(proj)
+      if proj.kind_of? CoordinateReferenceSystem
+        @crs = proj
+      elsif proj.kind_of? GeoScript::Projection
+        @crs = proj.crs
+      elsif proj.kind_of? String
+        @crs = CRS.decode proj
+
+        if @crs.nil?
+          @crs = CRS.parseWKT proj
+
+          if @crs.nil?
+            raise "Unable to determine projection from #{proj}"
+          end
+        end
+      end
+    end
+
+    def get_id
+      CRS.lookup_identifier(@crs, true).to_s
+    end
+
+    def get_wkt
+      @crs.to_s
+    end
+
+    def get_bounds
+      env = CRS.get_envelope @crs
+      if env
+        min = env.get_minimum
+        max = env.get_maximum
+        GeoScript::Geom::Bounds.create min.first, min.last, max.first, max.last
+      end
+    end
+
+    def get_geobounds
+      box = CRS.get_geographic_bounding_box @crs
+      if box
+        GeoScript::Geom::Bounds.create box.west_bound_longitude, box.south_bound_latitude, box.east_bound_longitude, box.north_bound_latitude, 'epsg:4326'
+      end
+    end
+
+    def transform(obj, dest)
+      from_crs = @crs
+      to_crs = Projection.new(dest).crs
+      transform = CRS.find_math_transform(from_crs, to_crs)
+
+      if obj.kind_of? Array
+      else
+        geometry_transform = GeometryCoordinateSequenceTransformer.new
+        geometry_transform.math_transform = transform
+        new_geom = geometry_transform.transform obj
+        geom_type = new_geom.class.to_s.split('::').last
+        klass = ['GeoScript', 'Geom', geom_type].inject(Module) {|acc, val| acc.const_get(val)}
+        klass.new(new_geom)
+      end
+    end
+
+    def self.reproject(obj, from_crs, to_crs)
+      Projection.new(from_crs).transform obj, to_crs
+    end
+
+    def self.projections
+      CRS.get_supported_codes('epsg').each do |code|
+        begin
+          Projection.new "epsg:#{code}"
+        rescue Java::OrgOpengisReferencing::NoSuchAuthorityCodeException
+          p "code: #{code} -> no such authority"
+        rescue Java::OrgOpengisReferencing::FactoryException => e
+          p "exception: #{e}"
+        end
+      end
+    end
+  end
+end

data/lib/geoscript/util.rb

@@ -0,0 +1 @@
+require 'util/bytes.rb'

data/lib/geoscript/util/bytes.rb

@@ -0,0 +1,30 @@
+JInt = java.lang.Integer
+
+module GeoScript
+  module Util
+    class Bytes
+      def self.decode(str, base)
+        str.to_java_bytes
+      end
+
+      def self.encode(bytes, base)
+        bytes.from_java_bytes
+      end
+
+      def self.byte_to_string(byte, base)
+        n = Math.log(256, base).ceil
+        s = byte < 0 ? java.lang.Integer.to_string(((b.abs ^ 0xff) + 0x01), base) : java.lang.Integer.to_string(b, base)
+        "%0#{n}d" % s
+      end
+
+      def self.string_to_byte(string, base)
+        int = string.to_i(base)
+        if int > 128
+          -1 * ((int ^ 0xff) + 0x01)
+        else
+          int
+        end
+      end
+    end
+  end
+end

data/lib/geoscript/version.rb

@@ -0,0 +1,3 @@
+module GeoScript
+  VERSION = '0.1.0.pre'
+end

data/lib/geoscript/workspace.rb

@@ -0,0 +1,21 @@
+java_import org.geotools.data.DataStore
+
+module GeoScript
+  class Workspace
+    DS_TYPES = {
+      'memory' => GeoScript::DataStore::Memory
+    }
+
+    attr_accessor :store
+
+    def initialize(store = nil, params = nil)
+      unless store
+        @store = GeoScript::DataStore::Memory.new(params)
+      else
+        if DS_TYPES[store]
+          @store = DS_TYPES[store].new(params)
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: geoscript
+version: !ruby/object:Gem::Version
+  version: 0.1.0.pre
+platform: java
+authors:
+- Scooter Wadsworth
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2014-01-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: geotools-jars
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rspec
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+description: GeoScript for JRuby - makes using GeoTools from JRuby easier and more fun.
+email:
+- scooterwadsworth@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/geoscript.rb
+- lib/geoscript/datastore.rb
+- lib/geoscript/feature.rb
+- lib/geoscript/geom.rb
+- lib/geoscript/io.rb
+- lib/geoscript/projection.rb
+- lib/geoscript/util.rb
+- lib/geoscript/version.rb
+- lib/geoscript/workspace.rb
+- lib/geoscript/datastore/memory.rb
+- lib/geoscript/feature/feature.rb
+- lib/geoscript/feature/field.rb
+- lib/geoscript/feature/schema.rb
+- lib/geoscript/geom/bounds.rb
+- lib/geoscript/geom/geom.rb
+- lib/geoscript/geom/linearring.rb
+- lib/geoscript/geom/linestring.rb
+- lib/geoscript/geom/multilinestring.rb
+- lib/geoscript/geom/multipoint.rb
+- lib/geoscript/geom/multipolygon.rb
+- lib/geoscript/geom/point.rb
+- lib/geoscript/geom/polygon.rb
+- lib/geoscript/io/feature/json.rb
+- lib/geoscript/io/geom/json.rb
+- lib/geoscript/io/geom/wkb.rb
+- lib/geoscript/io/geom/wkt.rb
+- lib/geoscript/layer/layer.rb
+- lib/geoscript/layer/shapefile.rb
+- lib/geoscript/util/bytes.rb
+homepage: https://github.com/scooterw/geoscript-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project:
+rubygems_version: 2.1.9
+signing_key:
+specification_version: 4
+summary: GeoScript is a library for making use of GeoTools from JRuby easier and more fun.
+test_files: []