aqila-mapas 0.4.4

data/lib/map/lat_lon_service.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+=begin
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
+/* Latitude/longitude spherical geodesy tools                         (c) Chris Veness 2002-2016  */
+/*                                                                                   MIT Licence  */
+/* www.movable-type.co.uk/scripts/latlong.html                                                    */
+/* www.movable-type.co.uk/scripts/geodesy/docs/module-latlon-spherical.html                       */
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
+Código portado de biblioteca LatLon do JS
+=end
+
+class Map::LatLonService
+  attr_reader :lat, :lon
+
+  def initialize(lat_or_coordinate, lon = nil)
+    if lon
+      @lat = lat_or_coordinate.to_f
+      @lon = lon.to_f
+    elsif lat_or_coordinate.is_a?(Array)
+      @lat = lat_or_coordinate.first.to_f
+      @lon = lat_or_coordinate.second.to_f
+    elsif lat_or_coordinate.is_a?(Hash)
+      lat = HashWithIndifferentAccess.new(lat_or_coordinate)
+      @lat = lat[:latitude].to_f
+      @lon = lat[:longitude].to_f
+    else
+      raise 'Parâmetros inválidos'
+    end
+
+    Float.include Map::Float
+  end
+
+  def bearing_to(point)
+    raise 'Point não é do tipo LatLon' unless point.is_a?(Map::LatLonService)
+
+    _φ1 = self.lat.to_radians
+    _φ2 = point.lat.to_radians
+    _Δλ = (point.lon - self.lon).to_radians
+
+    y = Math.sin(_Δλ) * Math.cos(_φ2)
+    x = Math.cos(_φ1) * Math.sin(_φ2) - Math.sin(_φ1) * Math.cos(_φ2) * Math.cos(_Δλ)
+    θ = Math.atan2(y, x)
+
+    (θ.to_degrees + 360) % 360
+  end
+
+  def destination_point(distance, bearing)
+    radius = 6371e3
+
+    # _φ2 = asin( sin_φ1⋅cosδ + cos_φ1⋅sinδ⋅cosθ )
+    # _λ2 = _λ1 + atan2( sinθ⋅sinδ⋅cos_φ1, cosδ − sin_φ1⋅sin_φ2 )
+    # see http://williams.best.vwh.net/avform.htm#LL
+
+    δ = distance / radius
+    θ = bearing.to_f.to_radians
+
+    _φ1 = self.lat.to_radians
+    _λ1 = self.lon.to_radians
+
+    _φ2 = Math.asin(Math.sin(_φ1)*Math.cos(δ) + Math.cos(_φ1)*Math.sin(δ)*Math.cos(θ))
+    x = Math.cos(δ) - Math.sin(_φ1) * Math.sin(_φ2)
+    y = Math.sin(θ) * Math.sin(δ) * Math.cos(_φ1)
+    _λ2 = _λ1 + Math.atan2(y, x)
+
+    self.class.new(_φ2.to_degrees, (_λ2.to_degrees + 540) % 360-180)
+  end
+
+  def distance_to(point)
+    radius = 6371e3
+
+    _φ1 = self.lat.to_radians
+    _λ1 = self.lon.to_radians
+
+    _φ2 = point.lat.to_radians
+    _λ2 = point.lon.to_radians
+
+    _Δφ = _φ2 - _φ1
+    _Δλ = _λ2 - _λ1
+
+    a = Math.sin(_Δφ/2) * Math.sin(_Δφ/2) + Math.cos(_φ1) * Math.cos(_φ2) * Math.sin(_Δλ/2) * Math.sin(_Δλ/2)
+    c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a))
+
+    radius * c
+  end
+
+  def to_hash
+    {
+      latitude: self.lat,
+      longitude: self.lon
+    }
+  end
+end

data/lib/map/polygon_service.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+class Map::PolygonService
+  CACHE_EXPIRES = 1.hours
+  POS_LATITUDE = 1
+  POS_LONGITUDE = 0
+
+  def initialize(glebas = nil)
+    @glebas = glebas
+  end
+
+  def inside_any_gleba?(point)
+    propriedade = inside_any_propriedade?(point)
+    talhoes = propriedade&.glebas || glebas
+    talhoes.each do |talhao|
+      coords = polygon(talhao)
+      coords.each do |coord|
+        return talhao if point_inside?(point, coord)
+      end
+    end
+
+    nil
+  end
+
+  def glebas
+    @glebas ||= Gleba.select(:cd_gleba, :cd_propriedade, :arquivo_kml, :descricao).active.with_kml
+  end
+
+  def propriedades
+    @propriedades ||= Propriedade.includes(:glebas).select(:cd_propriedade, :descricao).active
+  end
+
+  def inside_polygons?(point, polygons)
+    polygons.any? do |polygon|
+      point_inside?(point, polygon)
+    end
+  end
+
+  def inside_any_propriedade?(point)
+    propriedades.each do |propriedade|
+      return propriedade if point_inside_bounds?(point, propriedade.bounds)
+    end
+
+    nil
+  end
+
+  private
+
+  def point_inside_bounds?(point, bounds)
+    latitude = (point[:latitude] || point['latitude']).to_f
+    longitude = (point[:longitude] || point['longitude']).to_f
+
+    latitude.to_f.between?(bounds[:south_west][POS_LATITUDE].to_f, bounds[:north_east][POS_LATITUDE].to_f) &&
+      longitude.to_f.between?(bounds[:south_west][POS_LONGITUDE].to_f, bounds[:north_east][POS_LONGITUDE].to_f)
+  end
+
+  # Algoritmo portado de código javascript
+  # ray-casting algorithm based on
+  # http://www.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html
+  # https://github.com/substack/point-in-polygon
+  def point_inside?(point, polygon)
+    x = (point[:latitude] || point['latitude']).to_f
+    y = (point[:longitude] || point['longitude']).to_f
+
+    inside = false
+    i = 0
+    j = polygon.length - 1
+
+    polygon.length.times do
+      xi = (polygon[i][1] || polygon[i]['latitude']).to_f
+      yi = (polygon[i][0] || polygon[i]['longitude']).to_f
+
+      xj = (polygon[j][1] || polygon[j]['latitude']).to_f
+      yj = (polygon[j][0] || polygon[j]['longitude']).to_f
+
+      intersect = ((yi > y) != (yj > y)) && (x < (xj - xi) * (y - yi) / (yj - yi) + xi)
+
+      inside = !inside if intersect
+      i += 1
+      j = i - 1
+    end
+
+    inside
+  end
+
+  def coordinates(gleba)
+    if gleba.respond_to?(:coordinates)
+      gleba.coordinates
+    elsif gleba.respond_to?(:at)
+      gleba.at(:coordinates).text.strip
+    else
+      Map::KmlService.new(gleba.arquivo_kml).coordinates
+    end
+  end
+
+  def polygon(gleba)
+    SafeCacheService.new("#{gleba.id}/coordinates", expires_in: CACHE_EXPIRES, execute_if: Rails.env.production?)
+      .fetch { coordinates(gleba) }
+  end
+end

data/lib/map/rgeo_service.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class Map::RgeoService
+  attr_reader :factory
+
+  def initialize
+    @factory = RGeo::Geos.factory(srid: 3361)
+  end
+
+  def create_polygon(points)
+    raise 'Parâmetro inválido' unless points.is_a?(Array)
+
+    transformed = points.collect do |point|
+      create_point(point)
+    end
+
+    factory.polygon(factory.linear_ring(transformed))
+  end
+
+  def create_point(point)
+    if point.is_a?(Array)
+      point.first < point.second ? factory.point(point.second.to_f, point.first.to_f) : factory.point(point.first.to_f, point.second.to_f)
+    elsif point.is_a?(Hash)
+      factory.point((point['latitude'] || point[:latitude]).to_f, (point['longitude'] || point[:longitude]).to_f)
+    end
+  end
+
+  def polygon_inside_any_other?(base, other)
+    return false if base.nil? || other.nil?
+    return true if base.overlaps?(other) || other.overlaps?(base)
+    return true if base.contains?(other) || other.contains?(base)
+  end
+
+  def centroid(points)
+    polygon = create_polygon(points)
+    centroid = polygon.centroid
+    {
+      latitude: centroid.x,
+      longitude: centroid.y
+    }
+  end
+end

data/lib/map/shape_to_tif_service.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+# Converte um shape file para tif
+# 1. Rasteriza o shape
+# 2. Faz resample
+# 3. Aplica escala de cores
+class Map::ShapeToTifService
+  attr_reader :options, :shape_file
+
+  def initialize(shape_file)
+    @shape_file = shape_file
+    @services = []
+  end
+
+  def call(options)
+    @options = options
+    color_result = color
+    crop_service = Map::Gdal::CropService.new(color_result[:file])
+    original_file = color_result[:file]
+    color_result[:file] = crop_service.call({
+      reference: IO.read(options[:kml]),
+      s_srs: 'WGS84'
+    })
+    FileUtils.rm_rf(original_file)
+    color_result
+  ensure
+    clean_services
+  end
+
+  private
+
+  def raster
+    @services << Map::Gdal::RasterService.new(@shape_file)
+    raster_options = {
+      a_nodata: 0,
+      format: 'tif',
+      ot: 'Float',
+      a: options[:field],
+      ts: options[:ts] || '500 500'
+    }
+    raster_options[:te] = te if te
+    @services.last.call(raster_options)
+  end
+
+  def te
+    if options[:te]
+      options[:te]
+    elsif options[:kml]
+      Map::Gdal::OgriInfoService.new(options[:kml]).limits
+    end
+  end
+
+  def color
+    service = Map::Gdal::ColorizeService.new(resample)
+    color_table = options[:color_table] || service.generate_color_table
+    {
+      colors: colors(color_table),
+      json: json,
+      file: service.call(color_table:  color_table)
+    }
+  end
+
+  def resample
+    @services << Map::Gdal::TranslateService.new(raster)
+    @services.last.call({
+      tr: '0.00001 0.00001',
+      r: 'cubicspline'
+    })
+  end
+
+  def clean_services
+    @services.map(&:clean)
+  end
+
+  def json
+    service = Map::Gdal::Ogr2ogrService.new(@shape_file)
+    out = service.call({
+      f: 'GeoJSON',
+      select: options[:field]
+    })
+    parsed = JSON.parse(IO.read(out))
+    service.clean
+    parsed
+  end
+
+  def colors(color_table)
+    Map::Gdal::ColorizeService.format_color_table(color_table)
+  end
+end

data/lib/map/tile_service.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Map::TileService
+  def initialize(latitude, longitude, zoom)
+    @latitude = latitude
+    @longitude = longitude
+    @zoom = zoom
+  end
+
+  # http://wiki.openstreetmap.org/wiki/Slippy_map_tilenames#Lon..2Flat._to_tile_numbers_3
+  def points
+    lat_rad = @latitude/180 * Math::PI
+    squared_zoom = 2.0 ** @zoom
+    point_x = ((@longitude + 180.0) / 360.0 * squared_zoom).to_i
+    point_y = ((1.0 - Math::log(Math::tan(lat_rad) + (1 / Math::cos(lat_rad))) / Math::PI) / 2.0 * squared_zoom).to_i
+
+    {
+      x: point_x,
+      y: point_y
+    }
+  end
+end

data/lib/map/tiles_base.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Map::TilesBase
+  def path(folder)
+    if Rails.env.development?
+      File.join(Dir.pwd, 'public', 'reports', folder)
+    else
+      File.join('/tmp', 'relatorios', folder)
+    end
+  end
+end

data/lib/map/tracking_cleaner_service.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+class Map::TrackingCleanerService
+  attr_reader :trackings
+
+  def initialize(trackings)
+    @trackings = trackings.to_a
+  end
+
+  def speed
+    log('Velocidade') do
+      @trackings.select do |tracking|
+        tracking.st_acao == 'S' || tracking.speed.to_f > 0
+      end
+    end
+  end
+
+  def minimum_distance(distance)
+    log('Distância') do
+      last_valid = nil
+      trackings.select do |tracking|
+        selected = true
+
+        atual = Map::LatLonService.new(tracking.latitude, tracking.longitude)
+        if last_valid
+          tracking.distance = atual.distance_to(last_valid)
+          selected = tracking.distance >= distance
+        end
+        last_valid = Map::LatLonService.new(tracking.latitude, tracking.longitude)
+
+        selected
+      end
+    end
+  end
+
+  def accuracy_average
+    log('Precisão média') do
+      sum_accuracy = trackings.inject(0) do |result, tracking|
+        result + tracking.accuracy.to_f
+      end
+
+      if sum_accuracy > 0
+        accuracy_average = sum_accuracy / trackings.length
+        trackings.select do |tracking|
+          tracking.st_acao == 'S' || tracking.accuracy.to_f <= (accuracy_average * 1.5)
+        end
+      else
+        trackings
+      end
+    end
+  end
+
+  def simplify
+    log 'Simplify' do
+      points = trackings.map do |point|
+        {x: point.latitude.to_f, y: point.longitude.to_f}
+      end
+
+      points = SimplifyRb::Simplifier.new.process(points, 0.00001, false)
+
+      trackings.select do |point|
+        points.find{ |p| p[:x] == point.latitude.to_f && p[:y] == point.longitude.to_f }
+      end
+    end
+  end
+
+  private
+
+  def log(type)
+    Rails.logger.info "Antes da limpeza de #{type.green}: #{@trackings.length}".red
+
+    ret = yield
+
+    Rails.logger.info "Depois da Limpeza de #{type.green}: #{ret.length}".red
+
+    self.class.new(ret)
+  end
+end

data/lib/satellite/imagery_proccessor.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+class Satellite::ImageryProccessor
+  attr_accessor :blue, :green, :red, :near_infrared, :small_thumb, :large_thumb, :info
+  attr_accessor :rgb_service, :ndvi_service, :rgb_file, :ndvi_file
+
+  def initialize(bands_object)
+    self.blue          = bands_object[:blue]
+    self.green         = bands_object[:green]
+    self.red           = bands_object[:red]
+    self.near_infrared = bands_object[:near_infrared]
+    self.small_thumb   = bands_object[:small_thumb]
+    self.large_thumb   = bands_object[:large_thumb]
+    self.info          = bands_object[:info]
+  end
+
+  def proccess
+    Rails.logger.info 'Criando ndvi service...'
+    create_ndvi_service
+
+    Rails.logger.info 'Criando rgb service...'
+    create_rgb_service
+
+    Rails.logger.info 'Criando registro de Scene...'
+    create_scene
+  ensure
+    Rails.logger.info 'Processamento finalizado.'
+    rgb_service.try(:clean)
+    ndvi_service.try(:clean)
+    `rm -rf #{info[:files_path]}`
+  end
+
+  private
+
+  def create_rgb_service
+    self.rgb_service = Map::Gdal::RgbService.new([red, green, blue])
+    self.rgb_file = rgb_service.call
+  end
+
+  def create_ndvi_service
+    self.ndvi_service = Map::Gdal::NdviService.new(red, near_infrared)
+    self.ndvi_file = ndvi_service.call
+  end
+
+  def create_scene
+    warp_service = Map::Gdal::WarpService.new(rgb_file)
+    out = warp_service.call(t_srs: '"+proj=longlat +ellps=WGS84"')
+    bounds_info = JSON.parse(`gdalinfo #{out} -mm -json`)
+    warp_service.clean
+
+    translate_service = Map::Gdal::TranslateService.new(rgb_file)
+
+   Scene.create!(
+      scene: info[:scene],
+      date: info[:date],
+      source: info[:source],
+      cloud_cover: info[:cloud_cover],
+      ndvi: File.open(ndvi_file),
+      rgb: File.open(translate_service.to_png(tr: '128 128', a_nodata: '-9999')),
+      small_thumb: (File.open(small_thumb) if small_thumb.present?),
+      large_thumb: File.open(large_thumb),
+      bounds: {
+        lower_left: bounds_info['cornerCoordinates']['lowerLeft'].reverse,
+        upper_right: bounds_info['cornerCoordinates']['upperRight'].reverse
+      }
+    )
+  ensure
+    translate_service&.clean
+  end
+end

data/lib/satellite/landsat8/coordinate_converter_service.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Satellite
+  module Landsat8
+    class CoordinateConverterService
+      include HTTParty
+      base_uri 'https://landsatlook.usgs.gov/arcgis/rest/services/LLook_Outlines/MapServer/1'
+
+      attr_accessor :lat, :lon
+
+      def initialize(lat, lon)
+        self.lat = lat
+        self.lon = lon
+      end
+
+      def convert
+        response = self.class.get('/query', {
+          query: {
+            where: "MODE='D'",
+            geometry: "#{lon}, #{lat}",
+            geometryType: 'esriGeometryPoint',
+            spatialRel: 'esriSpatialRelIntersects',
+            outFields: '*',
+            returnGeometry: false,
+            returnTrueCurves: false,
+            returnIdsOnly: false,
+            returnCountOnly: false,
+            returnZ: false,
+            returnM: false,
+            returnDistinctValues: false,
+            f: 'json'
+          }.to_param
+        })
+
+        result = JSON.parse(response).dig('features', 0, 'attributes')
+        "#{result['PATH'].to_s.rjust(3, '0')}#{result['ROW'].to_s.rjust(3, '0')}"
+      end
+    end
+  end
+end

data/lib/satellite/landsat8/imagery_service.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+# Satellite LandSat8
+# 30m de resolução
+# Banda 2 = Azul
+# Banda 3 = Verde
+# Banda 4 = Vermelho: 640-690 nm
+# Banda 5 = Infravermelho próximo: 850-880 nm
+module Satellite
+  module Landsat8
+    class ImageryService
+      AWS_URL = 's3://landsat-pds/c1/L8'
+
+      attr_accessor :scene, :quantity
+
+      # $scene = { path: '000', row: '000' }
+      def initialize(scene, quantity = 2)
+        self.scene = "#{scene[:path]}/#{scene[:row]}"
+        self.quantity = quantity
+      end
+
+      def download_and_proccess
+        Rails.logger.info "[Landsat8 | #{scene}] Listando últimos #{quantity} arquivos..."
+        files = last
+
+        Rails.logger.info "[Landsat8 | #{scene}] Checando arquivos que precisam ser baixados..."
+        files.reject!{ |file| scene_already_proccessed?(file) }
+
+        Rails.logger.info "[Landsat8 | #{scene}] Baixando #{files.length} cenas..."
+        files.each_with_index do |file, index|
+          Rails.logger.info "[Landsat8 | #{scene}] Fazendo download da cena do dia #{file[:date]}..."
+          useful_files(file[:file]).map do |useful_file|
+            Thread.new {
+              Rails.logger.info "[Landsat8 | #{scene}] Fazendo download do arquivo #{useful_file}..."
+              `aws s3 cp #{AWS_URL}/#{scene}/#{file[:file]}/#{useful_file} "#{output_path}/#{file[:file]}/#{useful_file}"`
+              raise 'Error to execute aws s3 cp' unless $?.success?
+            }
+          end.map(&:join)
+
+          Rails.logger.info "[Landsat8 | #{scene}] Processando arquivos #{index.next}/#{files.length}."
+          Satellite::ImageryProccessor.new(band_object(file[:file])).proccess
+        end
+      end
+
+      def last
+        @lasts ||= `aws s3 ls #{AWS_URL}/#{scene}/`
+          .split("\n")
+          .select{ |file| file.end_with?('_RT/') } # Seleciona somente REAL TIME files - https://landsat.usgs.gov/landsat-collections
+          .map do |name|
+            name = name[/.*(LC08.+)\//,1]
+            date = name[/.+?_.+?_.+?_(.+?)_/, 1].to_date
+            {
+              file: name,
+              date: date
+            }
+          end
+          .sort_by{ |item| item[:date] }
+          .last(quantity)
+          .reverse
+      end
+
+      def useful_files(file_path)
+        all_files_from_last_scene = `aws s3 ls #{AWS_URL}/#{scene}/#{file_path}/`
+
+        all_files_from_last_scene.split("\n").inject([]) do |useful_files, current_file|
+          filtered_file = current_file[/.*(LC08.+(B[2-5].TIF|.jpg|MTL.txt))$/, 1]
+          useful_files << filtered_file if filtered_file.present?
+          useful_files
+        end.sort_by { |file| file.include?('.txt') && 1 || 2 }
+      end
+
+      def output_path
+        return @path if @path.present?
+
+        @path = File.join(Dir.pwd, 'public', 'system', 'data', 'imagens', 'landsat8')
+        FileUtils.mkdir_p(@path)
+        @path
+      end
+
+      def scene_already_proccessed?(file)
+        Scene
+          .landsat8
+          .by_date(file[:date])
+          .by_scene(scene.delete('/'))
+          .exists?
+      end
+
+      def info_object(scene_folder)
+        info_content = IO.read(Dir.glob(File.join(output_path, scene_folder,  '*.txt')).first)
+        @info_object = {
+          date: info_content.match(/DATE_ACQUIRED = (.+)/)[1].to_date,
+          cloud_cover: info_content.match(/CLOUD_COVER = (.+)/)[1],
+          scene: info_content.match(/LANDSAT_PRODUCT_ID = (.+)/)[1].split('_').third,
+          source: :landsat8,
+          base_path: output_path,
+          files_path: "#{output_path}/#{scene_folder}"
+        }
+      end
+
+      def band_object(file)
+        {
+          blue:               "#{output_path}/#{file}/#{file}_B2.TIF",
+          green:              "#{output_path}/#{file}/#{file}_B3.TIF",
+          red:                "#{output_path}/#{file}/#{file}_B4.TIF",
+          near_infrared:      "#{output_path}/#{file}/#{file}_B5.TIF",
+          small_thumb:        "#{output_path}/#{file}/#{file}_thumb_small.jpg",
+          large_thumb:        "#{output_path}/#{file}/#{file}_thumb_large.jpg",
+          info:               info_object(file)
+        } if File.exist?(File.join(output_path, file))
+      end
+    end
+  end
+end