geo_concerns 0.0.1

data/app/processors/geo_concerns/processors/raster/processor.rb

@@ -0,0 +1,27 @@
+module GeoConcerns
+  module Processors
+    module Raster
+      class Processor < Hydra::Derivatives::Processors::Processor
+        def process
+          raster_processor_class.new(source_path,
+                                     directives,
+                                     output_file_service: output_file_service).process
+        end
+
+        # Returns a raster processor class based on mime type passed in the directives object.
+        #
+        # @return raster processing class
+        def raster_processor_class
+          case directives.fetch(:input_format)
+          when 'text/plain; gdal-format=USGSDEM'
+            GeoConcerns::Processors::Raster::Dem
+          when 'application/octet-stream; gdal-format=AIG'
+            GeoConcerns::Processors::Raster::Aig
+          else
+            GeoConcerns::Processors::Raster::Base
+          end
+        end
+      end
+    end
+  end
+end

data/app/processors/geo_concerns/processors/vector.rb

@@ -0,0 +1,11 @@
+module GeoConcerns
+  module Processors
+    module Vector
+      extend ActiveSupport::Autoload
+
+      eager_autoload do
+        autoload :Processor
+      end
+    end
+  end
+end

data/app/processors/geo_concerns/processors/vector/base.rb

@@ -0,0 +1,68 @@
+module GeoConcerns
+  module Processors
+    module Vector
+      class Base < Hydra::Derivatives::Processors::Processor
+        include Hydra::Derivatives::Processors::ShellBasedProcessor
+        include GeoConcerns::Processors::BaseGeoProcessor
+        include GeoConcerns::Processors::Zip
+
+        def self.encode(path, options, output_file)
+          case options[:label]
+          when :thumbnail
+            encode_vector(path, options, output_file)
+          when :display_vector
+            reproject_vector(path, options, output_file)
+          end
+        end
+
+        def self.encode_vector(in_path, options, out_path)
+          tiff_path = "#{File.dirname(in_path)}/out.tif"
+          execute rasterize(in_path, options, tiff_path)
+          execute translate(tiff_path, options, out_path)
+          File.unlink(tiff_path)
+          File.unlink("#{out_path}.aux.xml")
+        end
+
+        def self.reproject_vector(in_path, options, out_path)
+          shapefile_path = intermediate_shapefile_path(out_path)
+          execute reproject(in_path, options, shapefile_path)
+          zip(shapefile_path, out_path)
+          FileUtils.rm_rf(shapefile_path)
+        end
+
+        # Returns a formatted gdal_rasterize command. Used to rasterize vector
+        # format into raster format.
+        #
+        # @param in_path [String] file input path
+        # #param options [Hash] creation options
+        # @param out_path [String] processor output file path
+        # @return [String] command for rasterizing vector dataset
+        def self.rasterize(in_path, options, out_path)
+          "gdal_rasterize -q -burn 0 -init 255 -ot Byte -ts "\
+            "#{options[:output_size]} -of GTiff #{in_path} #{out_path}"
+        end
+
+        # Returns a formatted ogr2ogr command. Used to reproject a
+        # vector dataset and save the output as a shapefile.
+        #
+        # @param in_path [String] file input path
+        # #param options [Hash] creation options
+        # @param out_path [String] processor output file path
+        # @return [String] command for reprojecting vector data
+        def self.reproject(in_path, options, out_path)
+          "env SHAPE_ENCODING= ogr2ogr -q -nln #{options[:basename]} "\
+            "-f 'ESRI Shapefile' -t_srs #{options[:output_srid]} '#{out_path}' '#{in_path}'"
+        end
+
+        # Returns a path to an intermediate shape file directory.
+        #
+        # @param path [String] file path to base temp path on
+        # @return [String] tempfile path
+        def self.intermediate_shapefile_path(path)
+          ext = File.extname(path)
+          "#{File.dirname(path)}/#{File.basename(path, ext)}/"
+        end
+      end
+    end
+  end
+end

data/app/processors/geo_concerns/processors/vector/processor.rb

@@ -0,0 +1,25 @@
+module GeoConcerns
+  module Processors
+    module Vector
+      class Processor < Hydra::Derivatives::Processors::Processor
+        def process
+          vector_processor_class.new(source_path,
+                                     directives,
+                                     output_file_service: output_file_service).process
+        end
+
+        # Returns a vector processor class based on mime type passed in the directives object.
+        #
+        # @return vector processing class
+        def vector_processor_class
+          case directives.fetch(:input_format)
+          when 'application/zip; ogr-format="ESRI Shapefile"'
+            GeoConcerns::Processors::Vector::Shapefile
+          else
+            GeoConcerns::Processors::Vector::Base
+          end
+        end
+      end
+    end
+  end
+end

data/app/processors/geo_concerns/processors/vector/shapefile.rb

@@ -0,0 +1,20 @@
+module GeoConcerns
+  module Processors
+    module Vector
+      class Shapefile < GeoConcerns::Processors::Vector::Base
+        include GeoConcerns::Processors::Zip
+
+        def self.encode(path, options, output_file)
+          unzip(path, output_file) do |zip_path|
+            case options[:label]
+            when :thumbnail
+              encode_vector(zip_path, options, output_file)
+            when :display_vector
+              reproject_vector(zip_path, options, output_file)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/processors/geo_concerns/processors/zip.rb

@@ -0,0 +1,31 @@
+module GeoConcerns
+  module Processors
+    module Zip
+      extend ActiveSupport::Concern
+
+      included do
+        # Unzips a file, invokes a block, and then deletes the unzipped file(s).
+        # Use to wrap processor methods for geo file formats that
+        # are zipped before uploading.
+        #
+        # @param in_path [String] file input path
+        # @param output_file [String] processor output file path
+        def self.unzip(in_path, output_file)
+          basename = File.basename(output_file, File.extname(output_file))
+          zip_out_path = "#{File.dirname(output_file)}/#{basename}_out"
+          execute "unzip -qq -j -d \"#{zip_out_path}\" \"#{in_path}\""
+          yield zip_out_path
+          FileUtils.rm_rf(zip_out_path)
+        end
+
+        # Zips a file or directory.
+        #
+        # @param in_path [String] file input path
+        # @param output_file [String] output zip file
+        def self.zip(in_path, output_file)
+          execute "zip -j -qq -r \"#{output_file}\" \"#{in_path}\""
+        end
+      end
+    end
+  end
+end

data/app/renderers/coverage_renderer.rb

@@ -0,0 +1,34 @@
+class CoverageRenderer < CurationConcerns::AttributeRenderer
+  def render
+    coverage = values.first if values
+    return '' unless coverage
+    markup(coverage).html_safe
+  end
+
+  private
+
+    def markup(coverage)
+      markup = ''
+      markup << %(<tr><th>#{label}</th>\n<td id='accordion'><ul class='tabular'>)
+      markup << value(coverage)
+      markup << toggle_button
+      markup << map(coverage)
+      markup << %(</ul></td></tr>)
+      markup
+    end
+
+    def value(coverage)
+      attributes = microdata_object_attributes(field).merge(class: "attribute #{field}")
+      %(<li#{html_attributes(attributes)}>#{attribute_value_to_html(coverage.to_s)})
+    end
+
+    def toggle_button
+      %( <a data-toggle='collapse' data-parent='accordion' href='#bbox' class='btn btn-default'>
+         Toggle Map</a>)
+    end
+
+    def map(coverage)
+      %(<div id='bbox' class='collapse in'></div>
+        <script>boundingBoxSelector({coverage: '#{coverage}', readonly: true});</script>)
+    end
+end

data/app/runners/geo_concerns/runners/raster_derivatives.rb

@@ -0,0 +1,9 @@
+module GeoConcerns
+  module Runners
+    class RasterDerivatives < Hydra::Derivatives::Runner
+      def self.processor_class
+        GeoConcerns::Processors::Raster::Processor
+      end
+    end
+  end
+end

data/app/runners/geo_concerns/runners/vector_derivatives.rb

@@ -0,0 +1,9 @@
+module GeoConcerns
+  module Runners
+    class VectorDerivatives < Hydra::Derivatives::Runner
+      def self.processor_class
+        GeoConcerns::Processors::Vector::Processor
+      end
+    end
+  end
+end

data/app/schemas/geo_concerns/basic_geo_metadata_optional.rb

@@ -0,0 +1,39 @@
+module GeoConcerns
+  class BasicGeoMetadataOptional < ActiveTriples::Schema
+    #
+    # The following properties are inherited from Curation Concerns' metadata
+    #
+    # @see https://github.com/projecthydra-labs/curation_concerns/blob/master/curation_concerns-models/app/models/concerns/curation_concerns/basic_metadata.rb
+    # Optional:
+    #   :contributor
+    #   :creator
+    #   :date_created (DC.created)
+    #   :description
+    #   :identifier
+    #   :language
+    #   :part_of
+    #   :publisher
+    #   :resource_type (DC.type)
+    #   :rights
+    #   :source
+    #   :subject
+    #   :tag (DC11.relation)
+    #
+
+    # Defines the placenames related to the layer
+    # @example
+    #   image.spatial = [ 'France', 'Spain' ]
+    property :spatial, predicate: ::RDF::Vocab::DC.spatial
+
+    # Defines the temporal coverage of the layer
+    # @example
+    #   vector.temporal = [ '1998-2006', 'circa 2000' ]
+    property :temporal, predicate: ::RDF::Vocab::DC.temporal
+
+    # Defines the issued date for the layer, using XML Schema dateTime format
+    #   (YYYY-MM-DDThh:mm:ssZ).
+    # @example
+    #   vector.issued = '2001-01-01T00:00:00Z'
+    property :issued, predicate: ::RDF::Vocab::DC.issued, multiple: false
+  end
+end

data/app/schemas/geo_concerns/basic_geo_metadata_required.rb

@@ -0,0 +1,25 @@
+module GeoConcerns
+  class BasicGeoMetadataRequired < ActiveTriples::Schema
+    #
+    # The following properties are inherited from Curation Concerns' metadata
+    #
+    # @see https://github.com/projecthydra-labs/curation_concerns/blob/master/curation_concerns-models/app/models/concerns/curation_concerns/required_metadata.rb
+    # Required:
+    #   :title
+    #   :date_uploaded (DC.dateSubmitted)
+    #   :date_modified (DC.modified)
+    #
+
+    # Defines the bounding box for the layer.
+    # We always assert units of decimal degrees and EPSG:4326 projection.
+    # @see http://dublincore.org/documents/dcmi-box/
+    # @example
+    #   vector.coverage = 'northlimit=43.039; eastlimit=-69.856; southlimit=42.943; westlimit=-71.032; units=degrees; projection=EPSG:4326'
+    property :coverage, predicate: ::RDF::Vocab::DC11.coverage, multiple: false
+
+    # Defines the institution which holds the layer
+    # @example
+    #   raster.provenance = 'Stanford University'
+    property :provenance, predicate: ::RDF::Vocab::DC.provenance, multiple: false
+  end
+end

data/app/services/authority_service.rb

@@ -0,0 +1,23 @@
+module AuthorityService
+  extend ActiveSupport::Concern
+
+  included do
+    mattr_accessor :authority
+  end
+
+  class_methods do
+    def select_options
+      authority.all.map do |element|
+        [element[:label], element[:id]]
+      end
+    end
+
+    def label(id)
+      (authority.find(id) || {}).fetch('term', nil)
+    end
+
+    def include?(id)
+      !authority.find(id).nil? && !authority.find(id).empty?
+    end
+  end
+end

data/app/services/geo_concerns/derivative_path.rb

@@ -0,0 +1,16 @@
+module GeoConcerns
+  class DerivativePath < CurationConcerns::DerivativePath
+    def self.extension_for(destination_name)
+      case destination_name
+      when 'thumbnail'
+        ".#{MIME::Types.type_for('jpg').first.extensions.first}"
+      when 'display_raster'
+        '.tif'
+      when 'display_vector'
+        '.zip'
+      else
+        ".#{destination_name}"
+      end
+    end
+  end
+end

data/app/services/image_format_service.rb

@@ -0,0 +1,4 @@
+class ImageFormatService
+  include AuthorityService
+  self.authority = Qa::Authorities::Local.subauthority_for('image_formats')
+end

data/app/services/metadata_format_service.rb

@@ -0,0 +1,4 @@
+class MetadataFormatService
+  include AuthorityService
+  self.authority = Qa::Authorities::Local.subauthority_for('metadata_formats')
+end

data/app/services/raster_format_service.rb

@@ -0,0 +1,4 @@
+class RasterFormatService
+  include AuthorityService
+  self.authority = Qa::Authorities::Local.subauthority_for('raster_formats')
+end

data/app/services/vector_format_service.rb

@@ -0,0 +1,4 @@
+class VectorFormatService
+  include AuthorityService
+  self.authority = Qa::Authorities::Local.subauthority_for('vector_formats')
+end

data/app/values/geo_concerns/coverage.rb

@@ -0,0 +1,36 @@
+module GeoConcerns
+  class Coverage
+    class ParseError < StandardError; end
+    class InvalidGeometryError < StandardError; end
+
+    attr_reader :n, :e, :s, :w
+
+    def self.parse(str)
+      n = parse_coordinate(str, /northlimit=([\.\d\-]+);/)
+      e = parse_coordinate(str, /eastlimit=([\.\d\-]+);/)
+      s = parse_coordinate(str, /southlimit=([\.\d\-]+);/)
+      w = parse_coordinate(str, /westlimit=([\.\d\-]+);/)
+      raise ParseError, str if n.nil? || e.nil? || s.nil? || w.nil?
+      new(n, e, s, w)
+    rescue
+      nil
+    end
+
+    def self.parse_coordinate(str, regex)
+      Regexp.last_match(1).to_f if str =~ regex
+    end
+
+    def initialize(n, e, s, w)
+      raise InvalidGeometryError, "n=#{n} < s=#{s}" if n.to_f < s.to_f
+      raise InvalidGeometryError, "e=#{e} < w=#{w}" if e.to_f < w.to_f
+      @n = n
+      @e = e
+      @s = s
+      @w = w
+    end
+
+    def to_s
+      "northlimit=#{n}; eastlimit=#{e}; southlimit=#{s}; westlimit=#{w}; units=degrees; projection=EPSG:4326"
+    end
+  end
+end

data/app/values/geo_concerns/time_period.rb

@@ -0,0 +1,31 @@
+module GeoConcerns
+  class TimePeriod
+    attr_accessor :doc, :initial_value
+    def initialize(initial_value, doc)
+      @initial_value = initial_value
+      @doc = doc
+      append_caldate
+      append_begdate
+      initial_value.uniq!
+    end
+
+    def value
+      return nil unless initial_value.present?
+      initial_value
+    end
+
+    private
+
+      def append_caldate
+        doc.at_xpath('//idinfo/timeperd/timeinfo/mdattim/sngdate/caldate | //idinfo/timeperd/timeinfo/sngdate/caldate').tap do |node|
+          initial_value << node.text[0..3] unless node.nil? # extract year only
+        end
+      end
+
+      def append_begdate
+        doc.at_xpath('//idinfo/timeperd/timeinfo/rngdates/begdate').tap do |node|
+          initial_value << node.text[0..3] unless node.nil? # extract year only
+        end
+      end
+  end
+end