aqila-mapas 0.4.4

data/lib/map/gdal/ndvi_service.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class Map::Gdal::NdviService
+  include Map::Gdal::Base
+
+  def initialize(tif_red, tif_near_red)
+    @tif_red = tif_red
+    @tif_near_red = tif_near_red
+  end
+
+  def call
+    tif_out = get_path_to_temp_file('calculated', 'tif')
+    add_to_clean(tif_out)
+    add_to_clean("#{tif_out}.aux.xml")
+
+    run_command(
+      %{
+        gdal_calc.py
+          --overwrite
+          -B #{@tif_red}
+          -A #{@tif_near_red}
+          --outfile=#{tif_out}
+          --calc="(A.astype(float)-B)/(A.astype(float)+B)"
+          --overwrite
+          --type=Float32
+          --NoDataValue=-9999
+      }.squish
+    )
+
+    tif_out
+  end
+end

data/lib/map/gdal/ogr2ogr_service.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+# ogr2ogr - Converts simple features data between file formats.
+# http://www.gdal.org/ogr2ogr.html
+class Map::Gdal::Ogr2ogrService
+  include Map::Gdal::Base
+
+  attr_reader :file
+  def initialize(file)
+    raise 'File does not exist' unless File.exist?(file)
+    @file = file
+  end
+
+  def call(options)
+    raise 'File does no exist' unless File.exist?(file)
+    raise 'Format does not specified' unless options[:f]
+
+    out = get_path_to_temp_file(:ogr2ogr, options[:f])
+    add_to_clean(out)
+
+    run_command(%{ogr2ogr #{options_to_command_line(options)} "#{out}" "#{file}"})
+    out
+  end
+end

data/lib/map/gdal/ogri_info_service.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class Map::Gdal::OgriInfoService
+  include Map::Gdal::Base
+
+  attr_reader :file
+  def initialize(file)
+    raise 'File does not exist' unless File.exist?(file)
+    @file = file
+  end
+
+  def layer_name
+    # quando é um shapefile a informação vem seguida do tipo de dado
+    # Exemplo: Campinho (Point)
+    call(q: '').gsub(/\d+:/, '').gsub(/\s\(.+$/, '').strip
+  end
+
+  def limits
+    # Saída de exemplo Extent: (-52.726602, -27.567020) - (-52.714728, -27.554208)
+    # O match retorna[1] (-52.726602, -27.567020) - (-52.714728, -27.554208)
+    # O primeiro gsub retorna (-52.726602, -27.567020) (-52.714728, -27.554208)
+    # O segundo gsub retorna -52.726602 -27.567020 -52.714728 -27.554208
+    call({}, layer_name)
+      .match(/Extent: (.+)/)[1]
+      .gsub(/\s-\s/, ' ')
+      .gsub(/[^0-9\.\s-]/, '')
+  end
+
+  private
+
+  def call(options = {}, layer = nil)
+    layer = "\"#{layer}\"" if layer
+    run_command(%{ogrinfo -geom=NO -ro #{options_to_command_line(options)} "#{file}" #{layer}})
+  end
+end

data/lib/map/gdal/polygonize_service.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'zip'
+
+class Map::Gdal::PolygonizeService
+  include Map::Gdal::Base
+
+  def initialize(tif_path)
+    @tif_path = tif_path
+  end
+
+  def call(options = {})
+    if options[:kml]
+      @tif_path = Map::Gdal::CropService.new(@tif_path).call(reference: IO.binread(options[:kml]))
+      add_to_clean(@tif_path)
+    end
+
+    file_id = "#{Time.current.to_i}-#{(rand * 1_000).to_i}"
+    destination_shp = get_path_to_temp_file('shapefile', 'shp', file_id)
+    zip_file = get_path_to_temp_file('shapefile', 'zip', file_id)
+
+    run_command(%{gdal_polygonize.py #{@tif_path} -f "ESRI Shapefile" #{destination_shp}})
+
+    Zip::File.open(zip_file, Zip::File::CREATE) do |zip|
+      %w(dbf prj shp shx).each do |extension|
+        file_name = "shapefile-#{file_id}.#{extension}"
+        file_with_path = get_path_to_temp_file('shapefile', extension, file_id)
+        zip.add(file_name, file_with_path)
+        add_to_clean(file_with_path)
+      end
+    end
+
+    add_to_clean(zip_file)
+    zip_file
+  end
+end

data/lib/map/gdal/raster_service.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class Map::Gdal::RasterService
+  include Map::Gdal::Base
+
+  def initialize(file_input)
+    raise 'File does not exist' unless File.exist?(file_input)
+
+    @file = file_input
+  end
+
+  def call(options)
+    out = get_path_to_temp_file(:raster, options[:format])
+    add_to_clean(out)
+    add_to_clean("#{out}.aux.xml")
+
+    format_out = if options[:format] == 'tif'
+      'GTiff'
+    else
+      options[:format].upcase
+    end
+
+    begin
+      run_command(%{gdal_rasterize -q -of #{format_out} #{options_to_command_line(options, :format)} -l "#{get_layer_name}" "#{@file}" "#{out}"})
+    rescue RuntimeError => re
+      if re.message.include?('Failed to find field')
+        cpg_iso = "#{get_file_name_with_path(@file)}.cpg"
+        run_command(%{echo 885910 > "#{cpg_iso}"})
+        retry
+      elsif
+        raise re
+      end
+    end
+    out
+  end
+end

data/lib/map/gdal/rgb_service.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class Map::Gdal::RgbService
+  include Map::Gdal::Base
+
+  attr_reader :merge
+
+  delegate :clean, to: :merge
+
+  def initialize(files)
+    @merge = Map::Gdal::MergeService.new(files)
+  end
+
+  def call
+    # http://www.processamentodigital.com.br/2013/11/23/qgis-2-0-composicao-colorida-rgb-para-imagens-landsat-8/
+
+    out = @merge.call([
+      '-separate',
+      '-co TFW=yes',
+      '-of GTiff'
+    ])
+
+    add_to_clean(out)
+
+    out
+  end
+end

data/lib/map/gdal/table_colors.txt

@@ -0,0 +1,52 @@
+# Exportar arquivo de mapa de cores gerado pela QGIS
+#INTERPOLATION:INTERPOLATED
+1,26,150,65,255,1.000000
+1.00142,37,155,68,255,1.001421
+1.00284,48,160,71,255,1.002843
+1.00426,60,166,75,255,1.004264
+1.00569,71,171,78,255,1.005686
+1.00711,83,177,81,255,1.007107
+1.00853,94,182,85,255,1.008529
+1.00995,106,188,88,255,1.009950
+1.01137,117,193,91,255,1.011371
+1.01279,128,199,95,255,1.012793
+1.01421,140,204,98,255,1.014214
+1.01564,151,210,101,255,1.015636
+1.01706,163,215,105,255,1.017057
+1.01848,171,219,111,255,1.018479
+1.0199,178,222,118,255,1.019900
+1.02132,185,225,125,255,1.021321
+1.02274,193,228,132,255,1.022743
+1.02416,200,231,139,255,1.024164
+1.02559,207,234,146,255,1.025586
+1.02701,215,237,153,255,1.027007
+1.02843,222,241,160,255,1.028429
+1.02985,229,244,167,255,1.029850
+1.03127,236,247,174,255,1.031271
+1.03269,244,250,181,255,1.032693
+1.03411,251,253,188,255,1.034114
+1.03554,254,251,188,255,1.035536
+1.03696,254,245,180,255,1.036957
+1.03838,254,238,172,255,1.038379
+1.0398,254,231,164,255,1.039800
+1.04122,254,225,157,255,1.041221
+1.04264,254,218,149,255,1.042643
+1.04406,253,212,141,255,1.044064
+1.04549,253,205,133,255,1.045486
+1.04691,253,198,126,255,1.046907
+1.04833,253,192,118,255,1.048329
+1.04975,253,185,110,255,1.049750
+1.05117,253,178,102,255,1.051171
+1.05259,252,170,95,255,1.052593
+1.05401,249,158,89,255,1.054014
+1.05544,246,146,84,255,1.055436
+1.05686,242,134,78,255,1.056857
+1.05828,239,122,73,255,1.058279
+1.0597,236,110,67,255,1.059700
+1.06112,233,97,61,255,1.061121
+1.06254,230,85,56,255,1.062543
+1.06396,227,73,50,255,1.063964
+1.06539,224,61,44,255,1.065386
+1.06681,221,49,39,255,1.066807
+1.06823,218,37,33,255,1.068229
+1.06965,215,25,28,255,1.069650

data/lib/map/gdal/tiles_service.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class Map::Gdal::TilesService
+  include Map::Gdal::Base
+
+  DEFAULT_ZOOM_MAX = 15
+
+  def initialize(file)
+    @file = file
+  end
+
+  def call(options = {})
+    tiles_folder = options[:output] || File.join(Dir.tmpdir, "tiles-#{(Time.current.to_i * rand).to_i}")
+
+    run_command("gdal2tiles.py --profile=mercator -z #{options[:zoom_min].to_i}-#{options[:zoom_max] || DEFAULT_ZOOM_MAX} #{@file} #{tiles_folder}")
+
+    add_to_clean(tiles_folder)
+
+    tiles_folder
+  end
+end

data/lib/map/gdal/translate_service.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class Map::Gdal::TranslateService
+  include Map::Gdal::Base
+
+  def initialize(file)
+    @file = file
+  end
+
+  def to_png(options = {})
+    self.call(options.merge({
+      of: 'PNG',
+      co: 'worldfile=yes',
+      scale: '',
+      ot: 'Byte'
+    }))
+  end
+
+  def to_jpeg(options = {})
+    self.call(options.merge({
+      of: 'JPEG',
+      co: 'worldfile=yes'
+    }))
+  end
+
+  def call(options = {})
+    out = get_path_to_temp_file(:translate, options[:of])
+
+    run_command("gdal_translate #{options_to_command_line(options)} #{@file} #{out}")
+
+    add_to_clean(out)
+    add_to_clean("#{out}.aux.xml")
+    add_to_clean(out.gsub('.jpg', '.wld'))
+
+    out
+  end
+end

data/lib/map/gdal/warp_service.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# gdalwarp - image reprojection and warping utility
+# http://www.gdal.org/gdalwarp.html
+class Map::Gdal::WarpService
+  include Map::Gdal::Base
+
+  attr_reader :tif
+  def initialize(tif)
+    @tif = tif
+  end
+
+  def call(options)
+    raise "Arquivo TIF inválido. [#{tif.inspect}]" unless tif && File.exist?(tif)
+
+    out = get_path_to_temp_file(:warp, :tif)
+    run_command(%{gdalwarp -q -overwrite #{options_to_command_line(options)} "#{tif}" "#{out}"})
+
+    add_to_clean(out)
+    out
+  end
+end

data/lib/map/gleba_tiles_service.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class Map::GlebaTilesService
+  ZOOM_MIN = 1
+  ZOOM_MAX = 15
+  OUTPUT_DIR = 'public/map_tiles'
+
+  def initialize(gleba)
+    @gleba = gleba
+  end
+
+  def download_all_tiles
+    download_service.download
+  end
+
+  def download_service
+    @download_service ||= Map::DownloadTilesService.new({
+      boundary_ne: kml_service.point_more_north_east,
+      boundary_sw: kml_service.point_more_south_west,
+      zoom_min: ZOOM_MIN,
+      zoom_max: ZOOM_MAX,
+      output_directory: OUTPUT_DIR
+    })
+  end
+
+  def kml_service
+    @kml_service ||= Map::KmlService.new(@gleba.arquivo_kml)
+  end
+end

data/lib/map/gpx_service.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class Map::GpxService
+  include Map::FileImportBasic
+
+  def initialize(gpx)
+    @gpx = gpx
+  end
+
+  def coordinates
+    unless @coordinates
+      xml_doc = Nokogiri::XML(@gpx)
+      coordinates = xml_doc.xpath("//*[local-name()='trkseg']")
+      raise 'Arquivo inválido' if coordinates.empty?
+      @coordinates = coordinates.to_a.collect do |coordinate|
+        coordinate.children.to_a.collect do |point|
+          to_coordinate(point)
+        end.compact
+      end
+    end
+
+    @coordinates
+  end
+
+  private
+
+  def to_coordinate(point)
+    [
+      point.attributes['lon'].value.to_f,
+      point.attributes['lat'].value.to_f
+    ]
+  rescue
+  end
+end

data/lib/map/kml_creator_line_service.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class Map::KmlCreatorLineService
+  def initialize
+    @lines = []
+  end
+
+  def add_line(coordinates)
+    @lines << coordinates
+    self
+  end
+
+  def to_xml
+    Nokogiri::XML::Builder.new do |xml|
+      xml.kml do
+        xml.Document do
+          xml.name 'KML_GENERATED'
+          @lines.each_with_index do |coordinates, index|
+            xml.Placemark do
+              xml.name "Line#{index}"
+              xml.LineString do
+                xml.tessellate 1
+                xml.coordinates coordinates.map{ |item| "#{item.second},#{item.first},0" }.join("\n")
+              end
+            end
+          end
+        end
+      end
+    end.to_xml
+  end
+end

data/lib/map/kml_creator_service.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class Map::KmlCreatorService
+  def add_polygon(polygon)
+    (@polygons ||= []) << polygon
+    self
+  end
+
+  def to_xml
+    Nokogiri::XML::Builder.new do |xml|
+      xml.kml do
+        xml.Document do
+          xml.name 'KML_GENERATED'
+          @polygons.to_a.each_with_index do |polygon, index|
+            xml.Placemark do
+              xml.name "Polygon#{index}"
+              xml.Polygon do
+                xml.outerBoundaryIs do
+                  xml.LinearRing do
+                    xml.tessellate 1
+                    xml.coordinates polygon.map{ |item| "#{item.second},#{item.first},0" }.join("\n")
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end.to_xml
+  end
+end

data/lib/map/kml_edit_service.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+class Map::KmlEditService
+  def initialize(raw_kml)
+    @raw_kml = raw_kml
+    adjust_invalid_kml!
+  end
+
+  # add extended data do KML
+  # Based on https://developers.google.com/kml/documentation/extendeddata
+  def add_definition_custom_field(name, type)
+    schema = Nokogiri::XML::Node.new('Schema', nokogiri)
+    schema['name'] = name
+    schema['id'] = "#{name}Id"
+    simple_field = Nokogiri::XML::Node.new('SimpleField', nokogiri)
+    simple_field['type'] = type
+    simple_field['name'] = name
+    schema << simple_field
+
+    document << schema
+
+    self
+  end
+
+  # Add new point to KML (Placemark)
+  def add_point(lat, lon, data = {})
+    index = document.css('Placemark').length + 1
+    placemark = Nokogiri::XML::Node.new('Placemark', nokogiri)
+    name = Nokogiri::XML::Node.new('name', nokogiri)
+    name.content = "Point #{index}"
+
+    # ExtendedData
+    data.each do |key, value|
+      add_extended_data(key, value, placemark)
+    end
+
+    # Point
+    point = Nokogiri::XML::Node.new('Point', nokogiri)
+    coordinates = Nokogiri::XML::Node.new('coordinates', nokogiri)
+    coordinates.content = "#{lon},#{lat}"
+    point << coordinates
+
+    placemark << name
+    placemark << point
+
+    document_or_folder << placemark
+
+    self
+  end
+
+  def add_default_value_to_placemarks(data)
+    data.each do |name, value|
+      check_definition!(name)
+
+      document.css('Placemark').each do |placemark|
+        add_extended_data(name, value, placemark)
+      end
+    end
+
+    self
+  end
+
+  def to_xml
+    nokogiri.to_xml
+  end
+
+  def remove_node(name)
+    document.css(name.to_s).each(&:remove)
+
+    self
+  end
+
+  private
+
+  def nokogiri
+    @nokogiri ||= Nokogiri::XML(@raw_kml)
+  end
+
+  def document
+    @document ||= nokogiri.at_css('Document')
+  end
+
+  def document_or_folder
+    @folder ||= nokogiri.at_css('Folder') || document
+  end
+
+  def check_definition!(name)
+    has_definition = document.css("Schema SimpleField[name=#{name}]").any?
+    raise "#{name} is not defined" unless has_definition
+  end
+
+  def add_extended_data(name, value, node)
+    check_definition!(name)
+
+    extendedData = Nokogiri::XML::Node.new('ExtendedData', nokogiri)
+    schemaData = Nokogiri::XML::Node.new('SchemaData', nokogiri)
+    schemaData['schemaUrl'] = "##{name}Id"
+    extendedData << schemaData
+
+    simpleData = Nokogiri::XML::Node.new('SimpleData', nokogiri)
+    simpleData['name'] = name
+    simpleData.content = value
+    schemaData << simpleData
+
+    node << extendedData
+  end
+
+  def adjust_invalid_kml!
+    # Existem alguns KMLs (inválidos) que o nodo root é KML e não existe um document dentro
+    # Nestes casos é necessário trocar o KML por Document
+    unless nokogiri.at_css('Document')
+      @raw_kml = @raw_kml.gsub('<kml', '<Document').gsub('</kml', '</Document')
+      @nokogiri = nil
+    end
+
+    # Gera um nome randomico para a layer
+    if document_or_folder
+      node_name = document_or_folder.at_css('name')
+      node_name.content = "layer_name_#{Time.current.to_i}"
+    end
+  end
+end

data/lib/map/kml_offset_service.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+class Map::KmlOffsetService
+  MINIMUM_POINTS = 3
+
+  attr_reader :kml
+
+  def initialize(kml)
+    @kml = kml
+  end
+
+  def call(offset)
+    polygons = coordinates.flat_map do |point|
+      call_python(point.map(&:reverse), offset) if point.length > MINIMUM_POINTS
+    end.compact
+
+    generate_kml(polygons)
+  end
+
+  private
+
+  def coordinates
+    @coordinates ||= Map::KmlService.new(kml).coordinates
+  end
+
+  def generate_kml(polygons)
+    service = Map::KmlCreatorService.new
+    polygons.each { |polygon| service.add_polygon(polygon) }
+    service.to_xml
+  end
+
+  # Este método gera um programa em python para depois rodar
+  # Foi a forma encontrada para poder usar a lib pyclipper
+  # https://pypi.python.org/pypi/pyclipper
+  def call_python(points, offset)
+    str = <<-EOF.strip_heredoc
+      import pyclipper
+
+      subj = (#{points.map { |point| "(#{point.first.to_f}, #{point.second.to_f})" }.join(',')})
+
+      pco = pyclipper.PyclipperOffset()
+      pco.AddPath(pyclipper.scale_to_clipper(subj), pyclipper.JT_ROUND, pyclipper.ET_CLOSEDPOLYGON)
+
+      solution = pco.Execute(#{offset})
+
+      print(pyclipper.scale_from_clipper(solution))
+    EOF
+
+    file = "/tmp/offset-#{Time.current.to_i}-#{(rand * 1_000).to_i}"
+    IO.write(file, str)
+    command = "python3 #{file}"
+    result = `#{command} 2>&1`
+    raise "Falha ao rodar comando [$ #{command}]\n[#{result}]" unless $?.success?
+
+    FileUtils.rm_rf(file)
+
+    JSON.parse(result)
+  end
+end

data/lib/map/kml_service.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class Map::KmlService
+  include Map::FileImportBasic
+
+  def initialize(kml)
+    @kml = kml
+  end
+
+  def coordinates
+    unless @coordinates
+      xml_doc =
+        if @kml.is_a? Nokogiri::XML::Element
+          @kml
+        else
+          Nokogiri::XML(@kml)
+        end
+      coordinates = xml_doc.xpath(".//*[local-name()='coordinates']")
+
+      @coordinates = coordinates.to_a.collect do |coordinate|
+        coordinate.text.split(' ').collect do |polygon|
+          string_to_coordinate(polygon)
+        end
+      end
+    end
+
+    @coordinates
+  end
+
+  private
+
+  def string_to_coordinate(str)
+    str.split(',')[0..1].map(&:to_f)
+  end
+end