geo_works 0.1.0

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

@@ -0,0 +1,41 @@
+module GeoWorks
+  module Processors
+    module Raster
+      class Base < Hydra::Derivatives::Processors::Processor
+        include Hydra::Derivatives::Processors::ShellBasedProcessor
+        include GeoWorks::Processors::BaseGeoProcessor
+        include GeoWorks::Processors::Image
+        include GeoWorks::Processors::Gdal
+
+        def self.encode(path, options, output_file)
+          case options[:label]
+          when :thumbnail
+            encode_raster(path, output_file, options)
+          when :display_raster
+            reproject_raster(path, output_file, options)
+          end
+        end
+
+        # Set of commands to run to encode the raster thumbnail.
+        # @return [Array] set of command name symbols
+        def self.encode_queue
+          [:translate, :convert]
+        end
+
+        # Set of commands to run to reproject the raster.
+        # @return [Array] set of command name symbols
+        def self.reproject_queue
+          [:warp, :compress]
+        end
+
+        def self.encode_raster(in_path, out_path, options)
+          run_commands(in_path, out_path, encode_queue, options)
+        end
+
+        def self.reproject_raster(in_path, out_path, options)
+          run_commands(in_path, out_path, reproject_queue, options)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module GeoWorks
+  module Processors
+    module Raster
+      class Dem < GeoWorks::Processors::Raster::Base
+        # Set of commands to run to encode the DEM thumbnail.
+        # @return [Array] set of command name symbols
+        def self.encode_queue
+          [:hillshade, :convert]
+        end
+
+        # Set of commands to run to reproject the DEM.
+        # @return [Array] set of command name symbols
+        def self.reproject_queue
+          [:hillshade, :warp]
+        end
+
+        # Executes a gdal hillshade command. Calculates hillshade
+        # on a raster that contains elevation data.
+        # @param in_path [String] file input path
+        # @param out_path [String] processor output file path
+        # @param options [Hash] creation options
+        def self.hillshade(in_path, out_path, _options)
+          execute "gdaldem hillshade -q "\
+                    "-of GTiff \"#{in_path}\" #{out_path}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module GeoWorks
+  module Processors
+    module Raster
+      class Info
+        attr_accessor :doc
+        attr_writer :min_max, :size
+
+        def initialize(path)
+          @doc = gdalinfo(path)
+        end
+
+        # Returns the min and max values for a raster.
+        # @return [String] computed min and max values
+        def min_max
+          @min_max ||= raster_min_max
+        end
+
+        # Returns the raster size.
+        # @return [Array] raster size
+        def size
+          @size ||= raster_size
+        end
+
+        private
+
+          # Runs the gdalinfo command and returns the result as a string.
+          # @param path [String] path to raster file
+          # @return [String] output of gdalinfo
+          def gdalinfo(path)
+            stdout, _stderr, _status = Open3.capture3("gdalinfo -mm #{path}")
+            stdout
+          end
+
+          # Given an output string from the gdalinfo command, returns
+          # a formatted string for the computed min and max values.
+          # @return [String] computed min and max values
+          def raster_min_max
+            match = %r{(?<=Computed Min/Max=).*?(?=\s)}.match(doc)
+            match ? match[0].tr(',', ' ') : ''
+          end
+
+          # Given an output string from the gdalinfo command, returns
+          # an array containing the raster width and height as strings.
+          # @return [String] raster size
+          def raster_size
+            match = /(?<=Size is ).*/.match(doc)
+            match ? match[0].tr(',', '') : ''
+          end
+      end
+    end
+  end
+end

data/app/processors/geo_works/processors/rendering.rb

@@ -0,0 +1,79 @@
+require 'simpler_tiles'
+
+module GeoWorks
+  module Processors
+    module Rendering
+      extend ActiveSupport::Concern
+      included do
+        # Renders a thumbnail from a vector dataset.
+        # @param in_path [String] file input path
+        # @param out_path [String] processor output file path
+        # @param options [Hash] creation options
+        def self.vector_thumbnail(in_path, out_path, options)
+          map = GeoWorks::Processors::Rendering.simple_tiles_map(in_path, options)
+          File.open(out_path, 'wb') { |f| f.write map.to_png }
+        end
+      end
+
+      class << self
+        # Builds a simple tiles map from a shapefile.
+        # @param in_path [String] file input path
+        # @param options [Hash] creation
+        # @return [SimplerTiles::Map] simple tiles map
+        def simple_tiles_map(in_path, options)
+          assign_rendering_options(in_path, options)
+          size = rendering_size(options)
+          SimplerTiles::Map.new do |m|
+            m.srs     = 'EPSG:4326'
+            m.bgcolor = SimplerTiles.config.bg_color
+            m.width   = size[0]
+            m.height  = size[1]
+            m.set_bounds(*simple_tiles_bounds(options))
+            add_shapefile_layer(in_path, m)
+          end
+        end
+
+        private
+
+          # Adds a shapefile layer to a simple tiles map.
+          # @param in_path [String] file input path
+          # @param options [Hash] creation options
+          def add_shapefile_layer(in_path, map)
+            Dir.glob("#{in_path}/*.shp").each do |shp|
+              map.layer shp do |l|
+                l.query "select * from '#{File.basename shp, '.shp'}'" do |q|
+                  q.styles SimplerTiles.config.to_h
+                end
+              end
+            end
+          end
+
+          # Re-orders options bounds for use with a simple tiles map.
+          # @param options [Hash] creation options
+          # @return [Array] simple tiles map bounds
+          def simple_tiles_bounds(options)
+            [options[:bounds][:east],
+             options[:bounds][:north],
+             options[:bounds][:west],
+             options[:bounds][:south]]
+          end
+
+          # Transforms the size directive into an array.
+          # @param options [Hash] creation options
+          # @return [Array] derivative size
+          def rendering_size(options)
+            options[:output_size].split(' ').map(&:to_i)
+          end
+
+          # Assigns new values from the vector info command to the creation options hash.
+          # @param in_path [String] file input path
+          # @param options [Hash] creation options
+          def assign_rendering_options(in_path, options)
+            vector_info = GeoWorks::Processors::Vector::Info.new(in_path)
+            options[:name] = vector_info.name
+            options[:bounds] = vector_info.bounds
+          end
+      end
+    end
+  end
+end

data/app/processors/geo_works/processors/vector.rb

@@ -0,0 +1,24 @@
+module GeoWorks
+  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"'
+            GeoWorks::Processors::Vector::Shapefile
+          else
+            GeoWorks::Processors::Vector::Base
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module GeoWorks
+  module Processors
+    module Vector
+      class Base < Hydra::Derivatives::Processors::Processor
+        include Hydra::Derivatives::Processors::ShellBasedProcessor
+        include GeoWorks::Processors::BaseGeoProcessor
+        include GeoWorks::Processors::Image
+        include GeoWorks::Processors::Ogr
+        include GeoWorks::Processors::Gdal
+        include GeoWorks::Processors::Rendering
+        include GeoWorks::Processors::Zip
+
+        def self.encode(path, options, output_file)
+          case options[:label]
+          when :thumbnail
+            encode_vector(path, output_file, options)
+          when :display_vector
+            reproject_vector(path, output_file, options)
+          end
+        end
+
+        # Set of commands to run to encode the vector thumbnail.
+        # @return [Array] set of command name symbols
+        def self.encode_queue
+          [:reproject, :vector_thumbnail, :trim, :center]
+        end
+
+        # Set of commands to run to reproject the vector.
+        # @return [Array] set of command name symbols
+        def self.reproject_queue
+          [:reproject, :zip]
+        end
+
+        def self.encode_vector(in_path, out_path, options)
+          run_commands(in_path, out_path, encode_queue, options)
+        end
+
+        def self.reproject_vector(in_path, out_path, options)
+          run_commands(in_path, out_path, reproject_queue, options)
+        end
+      end
+    end
+  end
+end

data/app/processors/geo_works/processors/vector/info.rb

@@ -0,0 +1,84 @@
+module GeoWorks
+  module Processors
+    module Vector
+      class Info
+        attr_accessor :doc
+        attr_writer :name, :driver
+
+        def initialize(path)
+          @doc = ogrinfo(path)
+        end
+
+        # Returns the vector dataset name
+        # @return [String] dataset name
+        def name
+          @name = vector_name
+        end
+
+        # Returns the ogr driver name
+        # @return [String] driver name
+        def driver
+          @driver = driver_name
+        end
+
+        # Returns vector geometry type
+        # @return [String] geom
+        def geom
+          @geom = vector_geom
+        end
+
+        # Returns vector bounds
+        # @return [String] bounds
+        def bounds
+          @bounds = vector_bounds
+        end
+
+        private
+
+          # Runs the ogrinfo command and returns the result as a string.
+          # @param path [String] path to vector file or shapefile directory
+          # @return [String] output of ogrinfo
+          def ogrinfo(path)
+            stdout, _stderr, _status = Open3.capture3("ogrinfo -ro -so -al #{path}")
+            stdout
+          end
+
+          # Given an output string from the ogrinfo command, returns
+          # the vector dataset name.
+          # @return [String] vector dataset name
+          def vector_name
+            match = /(?<=Layer name:\s).*?(?=\n)/.match(doc)
+            match ? match[0] : ''
+          end
+
+          # Given an output string from the ogrinfo command, returns
+          # the ogr driver used to read dataset.
+          # @return [String] ogr driver name
+          def driver_name
+            match = /(?<=driver\s`).*?(?=')/.match(doc)
+            match ? match[0] : ''
+          end
+
+          # Given an output string from the ogrinfo command, returns
+          # the vector geometry type.
+          # @return [String] vector geom
+          def vector_geom
+            match = /(?<=Geometry:\s).*?(?=\n)/.match(doc)
+            match ? match[0] : ''
+          end
+
+          # Given an output string from the ogrinfo command, returns
+          # the vector bounding box.
+          # @return [Hash] vector bounds
+          def vector_bounds
+            match = /(?<=Extent:\s).*?(?=\n)/.match(doc)
+            extent = match ? match[0] : ''
+
+            # remove parens and spaces, split into array, and assign elements to variables
+            w, s, e, n = extent.delete(' ').gsub(')-(', ',').delete('(').delete(')').split(',')
+            { north: n.to_f, east: e.to_f, south: s.to_f, west: w.to_f }
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module GeoWorks
+  module Processors
+    module Vector
+      class Shapefile < GeoWorks::Processors::Vector::Base
+        include GeoWorks::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, output_file, options)
+            when :display_vector
+              reproject_vector(zip_path, output_file, options)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/processors/geo_works/processors/zip.rb

@@ -0,0 +1,29 @@
+module GeoWorks
+  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, _options = {})
+          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, _options = {})
+          execute "zip -j -qq -r \"#{output_file}\" \"#{in_path}\""
+        end
+      end
+    end
+  end
+end

data/app/renderers/geo_works/coverage_renderer.rb

@@ -0,0 +1,39 @@
+module GeoWorks
+  class CoverageRenderer < Hyrax::Renderers::AttributeRenderer
+    include BoundingBoxHelper
+
+    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 << %(<div id='bbox' class='collapse in'></div>)
+        markup << bbox_display_inputs
+        markup << bbox_script_tag(coverage)
+        markup << toggle_button
+        markup << %(</ul></td></tr>)
+        markup
+      end
+
+      def toggle_button
+        %(
+          <a data-toggle='collapse' data-parent='accordion' href='#bbox' class='btn btn-default'>
+           Toggle Map</a>
+          )
+      end
+
+      def bbox_script_tag(coverage)
+        %(
+          <script>
+            boundingBoxSelector({coverage: '#{coverage}', readonly: true});
+          </script>
+        )
+      end
+  end
+end