atlas_middleware 0.0.1

data/lib/map_server_legend_info.rb

@@ -0,0 +1,17 @@
+require 'arcserver'
+
+class MapServerLegendInfo
+  def call(env)
+    request = Rack::Request.new(env)
+    
+    begin
+      map_server = ArcServer::MapServer.new(request['url'])
+      map_name = map_server.get_default_map_name
+      legend = map_server.get_default_map_name(:map_name => map_name)
+    rescue Exception => e
+      return [500, { "Content-Type" => "text/plain" }, e.message]
+    end
+
+    [200, { "Content-Type" => "application/json" }, legend.to_json]
+  end
+end

data/lib/pdf_template.rb

@@ -0,0 +1,206 @@
+#! /usr/bin/ruby
+
+$:.unshift File.join(File.dirname(__FILE__))
+
+require 'rubygems'
+require 'prawn'
+require 'prawn/format'
+require 'prawn/layout'
+#require 'prawn/fast_png'
+require 'open-uri'
+require 'esri/soap/map_server/map_server'
+require 'RMagick'
+require 'perftools'
+require 'base64'
+
+module Prawn
+  module Images
+    class PNG
+      alias_method :prawn_fast_png_old_initialize, :initialize
+
+      def initialize(data) #:nodoc:
+        @prawn_fast_png_data = data
+        prawn_fast_png_old_initialize(data)
+      end
+      
+      private
+      def unfilter_image_data
+        img = Magick::Image.from_blob(@prawn_fast_png_data).first
+
+        # get only one color value per pixel (Intensity) for grayscale+alpha images
+        format = color_type == 4 ? 'I' : 'RGB'
+
+        img_data      = img.export_pixels_to_str(0, 0, width, height, format)
+        alpha_channel = img.export_pixels_to_str(0, 0, width, height, 'A')
+
+        img.destroy!
+        @prawn_fast_png_data = nil
+
+        @img_data      = Zlib::Deflate.deflate(img_data)
+        @alpha_channel = Zlib::Deflate.deflate(alpha_channel)
+      end
+    end
+  end
+end
+
+
+def collect_legend_images
+  images = []
+  service = 'http://sampleserver1.arcgisonline.com/ArcGIS/services/Portland/ESRI_LandBase_WebMercator/MapServer'
+  legend_infos = ESRI::Soap::MapServer.get_legend_info(service, :image_return_type => :data)
+
+  legend_infos.each do |legend_info|
+    if legend_info.legendGroups[0].legendClasses.length == 1
+      img_data = Base64.decode64(Base64.decode64(legend_info.legendGroups[0].legendClasses[0].symbolImage.imageData))
+      images << {
+        :label => legend_info.name,
+        :image => Magick::Image.from_blob(img_data).first
+      }
+    else
+      legend_info.legendGroups[0].legendClasses.each do |legend_class|
+        img_data = Base64.decode64(Base64.decode64(legend_class.symbolImage.imageData))
+        images << {
+          :label => legend_class.label,
+          :image => Magick::Image.from_blob(img_data).first
+        }
+      end
+    end
+  end
+
+  images
+end
+
+def create_legend(pdf, opts = {})
+  images = collect_legend_images
+
+  columns = opts[:columns] || 4
+  rows    = opts[:rows]    || 4
+  gutter  = opts[:gutter]  || 0
+
+  pdf.define_grid(:columns => columns, :rows => rows, :gutter => gutter)
+
+  pdf.grid.rows.times do |i|
+    pdf.grid.columns.times do |j|
+      cell = pdf.grid(i,j)
+      pdf.bounding_box cell.top_left, :width => cell.width, :height => cell.height do
+        return if images.empty?
+        image = images.shift
+
+        pdf.image StringIO.new(image[:image].to_blob), :at => [pdf.bounds.top_left], :fit => [16, 16]
+        pdf.text_box image[:label],
+          :width    => cell.width,
+          :height   => cell.height,
+          :overflow => :ellipses,
+          :at       => [pdf.bounds.left + 20, pdf.bounds.top - 2]
+      end
+    end
+  end
+end
+
+def portrait_pdf
+  print 'creating portrait pdf...'
+  Prawn::Document.generate '/home/colin/portrait.pdf', :page_layout => :portrait do |pdf|
+    box = pdf.bounds
+    # html tag definitions
+    pdf.tags :h1 => { :font_size => '25', :font_style => :bold }
+    # html style definitions
+    pdf.styles :footer => { :color => "#999", :font_style => :italic }
+  
+    # header
+    pdf.bounding_box [box.left, box.top], :width => box.right, :height => 30 do
+      pdf.text "<h1>Title</h1>"
+    end
+
+    # map
+    pdf.bounding_box [box.left, pdf.cursor], :width => box.right, :height => box.width do
+      pdf.stroke_bounds
+      pdf.image "/home/colin/export.png", :at => [box.left, pdf.cursor], :width => box.width, :height => box.width
+    end
+
+    pdf.move_down 10
+    # toc
+    pdf.bounding_box [box.left, pdf.cursor], :width => box.right, :height => 140 do      
+      pdf.padded_box 5 do
+        create_legend(pdf, :columns => 4, :rows => 5)
+      end
+    end
+
+    # footer
+    pdf.canvas do
+      footer = {
+        :top_left => [box.absolute_left - 20, box.absolute_bottom - 15],
+        :width    => box.right + 40,
+        :height   => 15
+      }
+
+      pdf.bounding_box footer[:top_left], :width => footer[:width], :height => footer[:height] do
+        pdf.text '<span class="footer">NB Aquatic Bio-Web</span>'
+      end
+
+      pdf.bounding_box footer[:top_left], :width => footer[:width], :height => footer[:height] do
+        pdf.text "<span class=\"footer\">Generated on #{Time.now.strftime("%Y/%m/%d")}</span>", :align => :right
+      end
+    end
+  end
+  puts 'done'
+end
+
+def landscape_pdf
+  print 'creating landscape pdf...'
+  Prawn::Document.generate '/home/colin/landscape.pdf', :page_layout => :landscape do |pdf|
+    box = pdf.bounds
+    # html tag definitions
+    pdf.tags :h1 => { :font_size => '25', :font_style => :bold }
+    # html style definitions
+    pdf.styles :footer => { :color => "#999", :font_style => :italic }
+
+    # map
+    pdf.bounding_box [box.left, box.top], :width => box.height, :height => box.height do
+      pdf.stroke_bounds
+      pdf.image "/home/colin/export.png", :at => [box.left, box.top], :width => box.height, :height => box.height
+    end
+  
+    pdf.bounding_box [box.height + 10, box.top], :width => box.right - box.height - 10, :height => box.height do
+      # header
+      pdf.text "<h1>Title</h1>"
+      pdf.move_down 10
+
+      # toc
+      pdf.bounding_box [pdf.bounds.left, pdf.cursor], :width => pdf.bounds.right, :height => pdf.cursor do
+        create_legend(pdf, :columns => 1, :rows => 20)
+      end
+    end
+
+    # footer
+    pdf.canvas do
+      footer = {
+        :top_left => [box.absolute_left - 20, box.absolute_bottom - 15],
+        :width    => box.right + 40,
+        :height   => 15
+      }
+
+      pdf.bounding_box footer[:top_left], :width => footer[:width], :height => footer[:height] do
+        pdf.text '<span class="footer">NB Aquatic Bio-Web</span>'
+      end
+
+      pdf.bounding_box footer[:top_left], :width => footer[:width], :height => footer[:height] do
+        pdf.text "<span class=\"footer\">Generated on #{Time.now.strftime("%Y/%m/%d")}</span>", :align => :right
+      end
+    end
+  end
+  puts 'done'
+end
+
+PerfTools::CpuProfiler.start("/home/colin/pdf_perf") do
+  start_time = Time.now
+  portrait_pdf
+  end_time = Time.now
+  puts end_time - start_time
+end
+
+#
+#start_time = Time.now
+#landscape_pdf
+#end_time = Time.now
+#puts end_time - start_time
+#end

data/lib/postal_code_lookup.rb

@@ -0,0 +1,54 @@
+require 'rack'
+#require 'rack/cache'
+require 'activesupport'
+require 'httparty'
+
+class PostalCodeLookup
+  class ServiceException < Exception; end
+
+  include HTTParty
+  base_uri "geoservices.cgdi.ca"
+  format :xml
+  default_params :version => '1.0.0',
+    :request => 'GetPostalCode',
+    :sortarea => 'FSA'
+
+  def call(env)
+    request = Rack::Request.new(env)
+
+    headers = { "Content-Type" => "text/plain" }
+    r = Rack::Response # shorthand
+    begin
+      response = r.new(200, headers, find(request.params['code']))
+    rescue Exception => e
+      response = r.new(500, headers, e.message)
+    end
+#    response.max_age = 1.month
+
+    response.to_a
+  end
+
+  def find(code)
+    result = PostalCodeLookup.get('/cgi-bin/postalcode/postalcode.cgi', {
+        :query => { :code => code }
+      })
+
+    if error = result["ServiceExceptionReport"]
+      raise ServiceException.new(error['ServiceException'])
+    else
+      postal_code = result['PostalCodeLookup']['PostalCodeResultSet']['PostalCode']
+      location = postal_code["gml:centerOf"]["gml:Point"]
+      epsg = location["srsName"].split('#').pop
+      lng, lat = location["gml:coordinates"].split(',')
+      return {
+        :postal_code => postal_code["gml:name"],
+        :epsg => epsg,
+        :srs_name => location["srsName"],
+        :latitude => lat,
+        :longitude => lng,
+        :placename => postal_code["Placename"],
+        :province_or_territory => postal_code["ProvinceOrTerritory"]
+      }.to_json
+    end
+  end
+end

data/lib/print_map/job.rb

@@ -0,0 +1,49 @@
+require 'arcserver'
+require 'validatable'
+
+module PrintMap
+  class Job
+    include Validatable
+    include ArcServer::UrlHelper
+    # services validations
+    validates_length_of :services, :minimum => 1, :message => 'at least one service needs to be requested'
+    validates_true_for  :services, :logic => lambda { 
+      services.all? { |url| map_server?(url) }
+    }, :message => 'all services need to be valid MapServer urls'
+    # bbox validations
+    validates_length_of :bbox, :is => 4, :message => "bad format for 'bbox' - try bbox=xmin,ymin,xmax,ymax"
+    validates_true_for  :bbox, :logic => lambda { 
+      env['bbox'].to_s.split(',').all? { |b| b.to_s.match(/^[-|+]?\d*\.?\d*$/) }
+    }, :message => 'all bbox values must be valid positive/negative numbers'
+
+    attr_reader :env
+
+    def initialize(env = {})
+      @env = env
+    end
+
+    def services
+      @services ||= env['services'].to_s.split(',')
+    end
+
+    def bbox
+      @bbox ||= env['bbox'].to_s.split(',').collect{ |b| b.to_f }
+    end
+
+    def page_layout
+      @page_layout ||= (env['page_layout'] || 'portrait').to_sym
+    end
+
+    def page_size
+      @page_size ||= env['page_size'] || 'A4'
+    end
+
+    def dpi
+      @dpi ||= env['dpi'] || 96
+    end
+
+    def title
+      @title = env['title'] || 'Untitled Map'
+    end
+  end
+end

data/lib/print_map/legend_images_collector.rb

@@ -0,0 +1,34 @@
+require 'arcserver/map_server'
+
+module PrintMap
+  class LegendImagesCollector
+    def collect(opts = {})
+      puts 'creating map server object'
+      map_server = ArcServer::MapServer.new(opts[:url])
+
+      images = []
+      puts 'getting legend'
+      map_server.get_legend_info.each do |legend_info|
+        puts 'processing result'
+        legend_classes = legend_info[:legend_groups][0][:legend_classes]
+        if legend_classes.length == 1
+          img_data = Base64.decode64(legend_classes[0][:symbol_image][:image_data])
+          images << {
+            :label => legend_info[:name],
+            :data  => img_data
+          }
+        else
+          legend_classes.each do |legend_class|
+            img_data = Base64.decode64(legend_class[:symbol_image][:image_data])
+            images << {
+              :label => legend_class[:label],
+              :data  => img_data
+            }
+          end
+        end
+      end
+
+      images
+    end
+  end
+end

data/lib/print_map/map_exporter.rb

@@ -0,0 +1,20 @@
+require 'httparty'
+require 'RMagick'
+
+module PrintMap
+  class MapExporter
+    def export(opts = {})
+      service = opts[:service]
+      query = {
+        :bbox        => opts[:bbox],
+        :f           => :image,
+        :format      => :png24,
+        :transparent => true,
+        :size        => opts[:size],
+        :dpi         => opts[:dpi]
+      }
+      response = HTTParty.get("#{service}/export", :query => query)
+      Magick::Image.from_blob(response.body).first
+    end
+  end
+end

data/lib/print_map/pdf_generator.rb

@@ -0,0 +1,146 @@
+require 'prawn'
+require 'prawn/format'
+require 'prawn/layout'
+require 'open-uri'
+
+module PrintMap
+  class PdfGenerator
+    def generate(opts = {})
+      title  = opts[:title]
+      map_image  = opts[:map_image]
+      layout = opts[:page_layout]
+      legend_images = opts[:legend_images]
+
+      pdf = Prawn::Document.new(:page_layout => layout) do |pdf|
+        # html tag definitions
+        pdf.tags :h1 => { :font_size => '25', :font_style => :bold }
+        # html style definitions
+        pdf.styles :footer => { :color => "#999", :font_style => :italic }
+        # generate the pdf
+        send("generate_#{layout}_pdf", pdf, title, map_image, legend_images)
+        write_footer(pdf)
+      end
+
+      pdf
+    end
+
+    def generate_portrait_pdf(pdf, title, map_image, legend_images)
+      box = pdf.bounds
+      # header
+      pdf.bounding_box [box.left, box.top], :width => box.right, :height => 30 do
+        pdf.text "<h1>#{title}</h1>"
+      end
+
+      # map
+      pdf.bounding_box [box.left, pdf.cursor], :width => box.right, :height => box.width do
+        pdf.stroke_bounds
+        pdf.image StringIO.new(map_image.to_blob), :at => [box.left, pdf.cursor], :width => box.width, :height => box.width
+      end
+
+      pdf.move_down 10
+      # toc
+      pdf.bounding_box [box.left, pdf.cursor], :width => box.right, :height => 140 do
+        pdf.padded_box 5 do
+          create_legend(pdf, legend_images, :columns => 4, :rows => 5)
+          pdf.stroke_bounds
+        end
+      end
+    end
+
+    def generate_landscape_pdf(pdf, title, image, legend_images)
+      box = pdf.bounds
+      # map
+      pdf.bounding_box [box.left, box.top], :width => box.height, :height => box.height do
+        pdf.stroke_bounds
+        pdf.image StringIO.new(image.to_blob), :at => [box.left, box.top], :width => box.height, :height => box.height
+      end
+
+
+      pdf.bounding_box [box.height + 10, box.top], :width => box.right - box.height - 10, :height => box.height do
+        # header
+        pdf.text "<h1>#{title}</h1>"
+        pdf.move_down 10
+
+        # toc
+        pdf.bounding_box [pdf.bounds.left, pdf.cursor], :width => pdf.bounds.right, :height => pdf.cursor do
+          create_legend(pdf, legend_images, :columns => 1, :rows => 20)
+          pdf.stroke_bounds
+        end
+      end
+    end
+
+    def write_footer(pdf)
+      box = pdf.bounds
+      pdf.canvas do
+        footer = {
+          :top_left => [box.absolute_left - 20, box.absolute_bottom - 15],
+          :width    => box.right + 40,
+          :height   => 15
+        }
+
+        pdf.bounding_box footer[:top_left], :width => footer[:width], :height => footer[:height] do
+          pdf.text '<span class="footer">NB Aquatic Bio-Web</span>'
+        end
+
+        pdf.bounding_box footer[:top_left], :width => footer[:width], :height => footer[:height] do
+          pdf.text "<span class=\"footer\">Generated on #{Time.now.strftime("%Y/%m/%d")}</span>", :align => :right
+        end
+      end
+    end
+
+    def create_legend(pdf, legend_images, opts = {})
+      columns = opts[:columns] || 4
+      rows    = opts[:rows]    || 4
+      gutter  = opts[:gutter]  || 0
+
+      pdf.define_grid(:columns => columns, :rows => rows, :gutter => gutter)
+
+      pdf.grid.rows.times do |i|
+        pdf.grid.columns.times do |j|
+          cell = pdf.grid(i,j)
+          pdf.bounding_box cell.top_left, :width => cell.width, :height => cell.height do
+            return if legend_images.empty?
+            image = legend_images.shift
+
+            pdf.image StringIO.new(image[:data]), :at => [pdf.bounds.top_left], :fit => [16, 16]
+            pdf.text_box image[:label],
+              :width    => cell.width,
+              :height   => cell.height,
+              :overflow => :ellipses,
+              :at       => [pdf.bounds.left + 20, pdf.bounds.top - 2]
+          end
+        end
+      end
+    end    
+  end
+end
+
+module Prawn
+  module Images
+    class PNG
+      alias_method :prawn_fast_png_old_initialize, :initialize
+
+      def initialize(data) #:nodoc:
+        @prawn_fast_png_data = data
+        prawn_fast_png_old_initialize(data)
+      end
+
+      private
+      def unfilter_image_data
+        img = Magick::Image.from_blob(@prawn_fast_png_data).first
+
+        # get only one color value per pixel (Intensity) for grayscale+alpha images
+        format = color_type == 4 ? 'I' : 'RGB'
+
+        img_data      = img.export_pixels_to_str(0, 0, width, height, format)
+        alpha_channel = img.export_pixels_to_str(0, 0, width, height, 'A')
+
+        img.destroy!
+        @prawn_fast_png_data = nil
+
+        @img_data      = Zlib::Deflate.deflate(img_data)
+        @alpha_channel = Zlib::Deflate.deflate(alpha_channel)
+      end
+    end
+  end
+end

data/lib/print_map/worker.rb

@@ -0,0 +1,71 @@
+require 'prawn'
+require 'RMagick'
+require 'print_map/map_exporter'
+require 'print_map/pdf_generator'
+require 'print_map/legend_images_collector'
+
+module PrintMap
+  class Worker
+    attr_reader :current_job
+    attr_reader :map_exporter, :pdf_generator, :legend_images_collector
+
+    def initialize(config = {})
+      @map_exporter = config[:map_exporter] || MapExporter.new
+      @pdf_generator = config[:pdf_generator] || PdfGenerator.new
+      @legend_images_collector = config[:legend_images_collector] || LegendImagesCollector.new
+    end
+
+    def do_job(job)
+      @current_job = job
+      puts 'create composite map image'
+      map_image  = create_composite_map_image
+      puts 'collect legend images'
+      legend_images = collect_legend_images
+      puts 'generate pdf'
+      pdf = generate_pdf(map_image, legend_images)
+      puts 'cleanup'
+      map_image.destroy!
+      pdf
+    end
+
+    def create_composite_map_image
+      width, height = 540, 510
+      base_image = Magick::Image.new(width, height)
+      base_image.background_color = 'transparent'
+      base_image.format = 'PNG'
+
+      current_job.services.each do |map_service|
+        export_options = {
+          :service => map_service,
+          :dpi     => current_job.dpi,
+          :bbox    => current_job.bbox.join(','),
+          :size    => [width, height].join(',')
+        }
+        map_service_image = map_exporter.export(export_options)
+        base_image.composite!(map_service_image, Magick::CenterGravity, Magick::OverCompositeOp)
+        map_service_image.destroy!
+      end
+
+      base_image
+    end
+
+    def generate_pdf(map_image, legend_images)
+      opts = {
+        :title         => current_job.title,
+        :map_image     => map_image,
+        :page_layout   => current_job.page_layout,
+        :legend_images => legend_images
+      }
+      pdf_generator.generate(opts)
+    end
+
+    def collect_legend_images
+      images = []
+      current_job.services.each do |url|
+        puts 'fetching legends at ' + url
+        images << legend_images_collector.collect(:url => url)
+      end
+      images.flatten
+    end
+  end
+end

data/lib/print_map_service.rb

@@ -0,0 +1,48 @@
+require 'print_map/job'
+require 'print_map/worker'
+
+class PrintMapService
+  attr_reader :worker, :create_job
+
+  def initialize(opts = {})
+    @worker = opts[:worker] ||= PrintMap::Worker.new
+    @create_job = opts[:create_job] ||= proc { |opts| PrintMap::Job.new(opts) }
+  end
+
+  def call(env)
+    puts 'calling print map'
+    job = create_job.call(Rack::Request.new(env).params)
+    if job.valid?
+      puts 'valid job'
+      pdf = worker.do_job(job)
+      puts 'rendering to client'
+      # now stream the pdf to the client
+      [
+        200, {
+          "Content-Type" => "application/pdf", 
+          "Content-Disposition" => "attachment; filename=\"#{job.title}.pdf\""
+        },
+        pdf.render
+      ]
+    else
+      create_invalid_job_response(job)
+    end
+
+    rescue Exception => e
+      create_error_response(e)
+  end
+
+  def create_invalid_job_response(job)
+    body = "Print map failed because of the following errors:\n#{job.errors.full_messages.join("\n")}"
+    puts 'failed to generate print map:'
+    puts body
+    [500, { "Content-Type" => "text/plain" }, body]
+  end
+
+  def create_error_response(e)
+    body = "An internal error occurred:\n#{e.message}"
+    puts 'failed to generate print map:'
+    puts body
+    [500, { "Content-Type" => "text/plain" }, body]
+  end
+end

data/lib/rest_proxy.rb

@@ -0,0 +1,15 @@
+require 'rack'
+require 'httparty'
+
+class RestProxy
+  def call(env)
+    request = Rack::Request.new(env)
+    url = request.params.delete('url')
+    call_proxy(url)
+  end
+
+  def call_proxy(url)
+    response = HTTParty.get(url, :query => { :f => :json })
+    [response.code, response.headers, response.body]
+  end
+end