geo_works 0.1.0

data/app/presenters/geo_works/geo_works_show_presenter.rb

@@ -0,0 +1,48 @@
+module GeoWorks
+  class GeoWorksShowPresenter < Hyrax::WorkShowPresenter
+    delegate :spatial, :temporal, :issued, :coverage, :provenance, :layer_modified,
+             :identifier, to: :solr_document
+    class_attribute :file_format_service
+
+    def geo_file_set_presenters
+      # filter for geo file sets
+      file_set_presenters.select do |member|
+        file_format_service.include? member.solr_document.fetch(:geo_mime_type_tesim, [])[0]
+      end
+    end
+
+    def external_metadata_file_set_presenters
+      # filter for external metadata files
+      file_set_presenters.select do |member|
+        MetadataFormatService.include? member.solr_document.fetch(:geo_mime_type_tesim, [])[0]
+      end
+    end
+
+    def parent_work_presenters
+      # filter out collection presenters
+      member_of_presenters.select do |member|
+        member.model_name.name != "Collection"
+      end
+    end
+
+    def member_of_presenters
+      Hyrax::PresenterFactory.build_presenters(member_of_ids,
+                                               collection_presenter_class,
+                                               *presenter_factory_arguments)
+    end
+
+    def member_of_ids
+      ActiveFedora::SolrService.query("{!field f=member_ids_ssim}#{id}",
+                                      fl: ActiveFedora.id_field)
+                               .map { |x| x.fetch(ActiveFedora.id_field) }
+    end
+
+    def attribute_to_html(field, options = {})
+      if field == :coverage
+        GeoWorks::CoverageRenderer.new(field, send(field), options).render
+      else
+        super field, options
+      end
+    end
+  end
+end

data/app/presenters/geo_works/image_work_show_presenter.rb

@@ -0,0 +1,5 @@
+module GeoWorks
+  class ImageWorkShowPresenter < GeoWorksShowPresenter
+    self.file_format_service = ImageFormatService
+  end
+end

data/app/presenters/geo_works/raster_work_show_presenter.rb

@@ -0,0 +1,5 @@
+module GeoWorks
+  class RasterWorkShowPresenter < GeoWorksShowPresenter
+    self.file_format_service = GeoWorks::RasterFormatService
+  end
+end

data/app/presenters/geo_works/vector_work_show_presenter.rb

@@ -0,0 +1,5 @@
+module GeoWorks
+  class VectorWorkShowPresenter < GeoWorksShowPresenter
+    self.file_format_service = VectorFormatService
+  end
+end

data/app/processors/geo_works/geoblacklight_event_processor.rb

@@ -0,0 +1,29 @@
+module GeoWorks
+  class GeoblacklightEventProcessor
+    attr_reader :event
+    def initialize(event)
+      @event = event
+    end
+
+    delegate :process, to: :processor
+
+    private
+
+      def event_type
+        event['event']
+      end
+
+      def processor
+        case event_type
+        when 'CREATED'
+          UpdateProcessor.new(event)
+        when 'UPDATED'
+          UpdateProcessor.new(event)
+        when 'DELETED'
+          DeleteProcessor.new(event)
+        else
+          UnknownEvent.new(event)
+        end
+      end
+  end
+end

data/app/processors/geo_works/geoblacklight_event_processor/delete_processor.rb

@@ -0,0 +1,13 @@
+module GeoWorks
+  class GeoblacklightEventProcessor
+    class DeleteProcessor < Processor
+      def process
+        index.delete_by_query "layer_slug_s:#{RSolr.solr_escape(id)}"
+        index.commit
+        true
+      rescue RSolr::Error::Http
+        false
+      end
+    end
+  end
+end

data/app/processors/geo_works/geoblacklight_event_processor/processor.rb

@@ -0,0 +1,28 @@
+module GeoWorks
+  class GeoblacklightEventProcessor
+    class Processor
+      attr_reader :event
+      def initialize(event)
+        @event = event
+      end
+
+      private
+
+        def event_type
+          event['event']
+        end
+
+        def id
+          event['id']
+        end
+
+        def doc
+          event['doc']
+        end
+
+        def index
+          RSolr.connect(url: GeoWorks::Geoblacklight.config['url'])
+        end
+    end
+  end
+end

data/app/processors/geo_works/geoblacklight_event_processor/unknown_event.rb

@@ -0,0 +1,15 @@
+module GeoWorks
+  class GeoblacklightEventProcessor
+    class UnknownEvent < Processor
+      attr_reader :event
+      def initialize(event)
+        @event = event
+      end
+
+      def process
+        Rails.logger.info("Unable to process event type #{event_type}")
+        false
+      end
+    end
+  end
+end

data/app/processors/geo_works/geoblacklight_event_processor/update_processor.rb

@@ -0,0 +1,15 @@
+module GeoWorks
+  class GeoblacklightEventProcessor
+    class UpdateProcessor < Processor
+      def process
+        index.update params: { overwrite: true },
+                     data: [doc].to_json,
+                     headers: { 'Content-Type' => 'application/json' }
+        index.commit
+        true
+      rescue RSolr::Error::Http
+        false
+      end
+    end
+  end
+end

data/app/processors/geo_works/processors/base_geo_processor.rb

@@ -0,0 +1,81 @@
+module GeoWorks
+  module Processors
+    module BaseGeoProcessor
+      extend ActiveSupport::Concern
+
+      included do
+        # Chains together and recursively runs a set of commands.
+        # Except for the last command in the queue, a temp file
+        # is created as output and is then fed into the input of the next.
+        # Temp files are deleted in reverse order after the last command
+        # is run. The commands must have the same method signature:
+        # command_name(in_path, out_path, options)
+        #
+        # @param in_path [String] file input path
+        # @param out_path [String] processor output file path
+        # @param method_queue [Array] set of commands to run
+        # @param options [Hash] creation options to pass
+        def self.run_commands(in_path, out_path, method_queue, options)
+          next_step = method_queue.shift
+          if method_queue.empty?
+            method(next_step).call(in_path, out_path, options)
+          else
+            temp = temp_path(out_path)
+            method(next_step).call(in_path, temp, options)
+            run_commands(temp, out_path, method_queue, options)
+            FileUtils.rm_rf(temp)
+          end
+        end
+
+        # Returns a path to an intermediate temp file or directory.
+        # @param path [String] input file path to base temp path on
+        # @return [String] tempfile path
+        def self.temp_path(path)
+          time = (Time.now.to_f * 1000).to_i
+          "#{File.dirname(path)}/#{File.basename(path, File.extname(path))}_#{time}"
+        end
+      end
+
+      def options_for(_format)
+        {
+          label: label,
+          output_size: output_size,
+          output_srid: output_srid,
+          basename: basename,
+          id: id
+        }
+      end
+
+      # Returns the label directive or an empty string.
+      # @return [Sting] output label
+      def label
+        directives.fetch(:label, '')
+      end
+
+      # Transforms the size directive into a GDAL size parameter.
+      # @return [String] derivative size
+      def output_size
+        return unless directives[:size]
+        directives[:size].tr('x', ' ')
+      end
+
+      # Gets srid for reprojection derivative or returns WGS 84.
+      # @return [String] spatial reference code
+      def output_srid
+        directives.fetch(:srid, 'EPSG:4326')
+      end
+
+      # Extracts the base file name (without extension) from the source file path.
+      # @return [String] base file name for source
+      def basename
+        File.basename(source_path, File.extname(source_path))
+      end
+
+      # Gets the fileset id or returns nil.
+      # @return [String] fileset id
+      def id
+        directives.fetch(:id, nil)
+      end
+    end
+  end
+end

data/app/processors/geo_works/processors/gdal.rb

@@ -0,0 +1,49 @@
+module GeoWorks
+  module Processors
+    module Gdal
+      extend ActiveSupport::Concern
+
+      included do
+        # Executes a gdal_translate command. Used to translate a raster
+        # format into a different format. Also used in generating thumbnails
+        # from vector data.
+        # @param in_path [String] file input path
+        # @param out_path [String] processor output file path
+        # @param options [Hash] creation options
+        def self.translate(in_path, out_path, _options)
+          execute "gdal_translate -q -ot Byte -of GTiff \"#{in_path}\" #{out_path}"
+        end
+
+        # Executes a gdalwarp command. Used to transform a raster
+        # from one projection into another.
+        # @param in_path [String] file input path
+        # @param out_path [String] processor output file path
+        # @param options [Hash] creation options
+        def self.warp(in_path, out_path, options)
+          execute "gdalwarp -q -r bilinear -t_srs #{options[:output_srid]} "\
+                  "#{in_path} #{out_path} -co 'COMPRESS=NONE'"
+        end
+
+        # Executes a gdal_translate command. Used to compress
+        # a previously uncompressed raster.
+        # @param in_path [String] file input path
+        # @param out_path [String] processor output file path
+        # @param options [Hash] creation options
+        def self.compress(in_path, out_path, options)
+          execute "gdal_translate -q -ot Byte -a_srs #{options[:output_srid]} "\
+                    "#{in_path} #{out_path} -co 'COMPRESS=LZW'"
+        end
+
+        # Executes a 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
+        def self.rasterize(in_path, out_path, options)
+          execute "gdal_rasterize -q -burn 0 -init 255 -ot Byte -ts "\
+                    "#{options[:output_size]} -of GTiff #{in_path} #{out_path}"
+        end
+      end
+    end
+  end
+end

data/app/processors/geo_works/processors/image.rb

@@ -0,0 +1,66 @@
+require 'mini_magick'
+
+module GeoWorks
+  module Processors
+    module Image
+      extend ActiveSupport::Concern
+      included do
+        # Uses imagemagick to resize an image and convert it to the output format.
+        # Keeps the aspect ratio of the original image and adds padding to
+        # to the output image. The file extension is the output format.
+        # @param in_path [String] file input path
+        # @param out_path [String] processor output file path.
+        # @param options [Hash] creation options
+        # @option options [String] `:output_size` as "w h" or "wxh"
+        # rubocop:disable Metrics/MethodLength
+        def self.convert(in_path, out_path, options)
+          size = options[:output_size].tr(' ', 'x')
+          convert = MiniMagick::Tool::Convert.new(whiny: false)
+          convert << in_path
+          convert << "-resize"
+          convert << size
+          convert << "-extent"
+          convert << size
+          convert << "-background"
+          convert << "white"
+          convert << "-gravity"
+          convert << "center"
+          convert << out_path
+
+          # suppress stderr b/c geotiffs return 'unknown field' warnings
+          convert.call { |_stdout, _stderr| }
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        # Trims extra whitespace.
+        # @param in_path [String] file input path
+        # @param out_path [String] processor output file path.
+        # @param options [Hash] creation options
+        def self.trim(in_path, out_path, _options)
+          MiniMagick::Tool::Convert.new do |convert|
+            convert << in_path
+            convert << "-trim"
+            convert << out_path
+          end
+        end
+
+        # Centers and pads image.
+        # @param in_path [String] file input path
+        # @param out_path [String] processor output file path.
+        # @param options [Hash] creation options
+        def self.center(in_path, out_path, options)
+          MiniMagick::Tool::Convert.new do |convert|
+            convert << "-size"
+            convert << options[:output_size].tr(' ', 'x')
+            convert << "xc:white"
+            convert << in_path
+            convert << "-gravity"
+            convert << "center"
+            convert << "-composite"
+            convert << out_path
+          end
+        end
+      end
+    end
+  end
+end

data/app/processors/geo_works/processors/ogr.rb

@@ -0,0 +1,19 @@
+module GeoWorks
+  module Processors
+    module Ogr
+      extend ActiveSupport::Concern
+
+      included do
+        # Executes a 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
+        def self.reproject(in_path, out_path, options)
+          execute "env SHAPE_ENCODING= ogr2ogr -q -nln #{options[:id]} -f 'ESRI Shapefile'"\
+                    " -t_srs #{options[:output_srid]} -preserve_fid '#{out_path}' '#{in_path}'"
+        end
+      end
+    end
+  end
+end

data/app/processors/geo_works/processors/raster.rb

@@ -0,0 +1,26 @@
+module GeoWorks
+  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'
+            GeoWorks::Processors::Raster::Dem
+          when 'application/octet-stream; gdal-format=AIG'
+            GeoWorks::Processors::Raster::Aig
+          else
+            GeoWorks::Processors::Raster::Base
+          end
+        end
+      end
+    end
+  end
+end

data/app/processors/geo_works/processors/raster/aig.rb

@@ -0,0 +1,40 @@
+module GeoWorks
+  module Processors
+    module Raster
+      class Aig < GeoWorks::Processors::Raster::Base
+        include GeoWorks::Processors::Zip
+
+        def self.encode(path, options, output_file)
+          unzip(path, output_file) do |zip_path|
+            info = Info.new(zip_path)
+            options[:min_max] = info.min_max
+            case options[:label]
+            when :thumbnail
+              encode_raster(zip_path, output_file, options)
+            when :display_raster
+              reproject_raster(zip_path, output_file, options)
+            end
+          end
+        end
+
+        # Set of commands to run to reproject the AIG.
+        # @return [Array] set of command name symbols
+        def self.reproject_queue
+          [:warp, :translate]
+        end
+
+        # Executes a gdal_translate command to translate a raster
+        # format into a different format with a scaling options. This command
+        # scales the min and max values of the raster into the 0 to 255 range.
+        # Scale is inverted (255 to 0) to create a better visualization.
+        # @param in_path [String] file input path
+        # @param out_path [String] processor output file path
+        # @param options [Hash] creation options
+        def self.translate(in_path, out_path, options)
+          execute "gdal_translate -scale #{options[:min_max]} 255 0 "\
+                    "-q -ot Byte -of GTiff \"#{in_path}\" #{out_path}"
+        end
+      end
+    end
+  end
+end