aipp 1.0.0 → 2.0.0

data/lib/aipp/regions/LF/d_p_r_airspaces.rb

@@ -1,56 +0,0 @@
-module AIPP
-  module LF
-
-    class DPRAirspaces < AIP
-
-      include AIPP::LF::Helpers::Base
-
-      # Map source types to type and optional local type
-      SOURCE_TYPES = {
-        'D' => { type: 'D' },
-        'P' => { type: 'P' },
-        'R' => { type: 'R' },
-        'ZIT' => { type: 'P', local_type: 'ZIT' }
-      }.freeze
-
-      # Radius to use for zones consisting of one point only
-      POINT_RADIUS = AIXM.d(1, :km).freeze
-
-      def parse
-        SOURCE_TYPES.each do |source_type, target|
-          verbose_info("processing #{source_type}")
-          cache.espace.css(%Q(Espace[lk^="[LF][#{source_type} "])).each do |espace_node|
-# UPSTREAM: Espace[pk=300343] has no Partie/Volume (reported)
-next if espace_node['pk'] == '300343'
-            partie_node = cache.partie.at_css(%Q(Partie:has(Espace[pk="#{espace_node['pk']}"])))
-            volume_node = cache.volume.at_css(%Q(Volume:has(Partie[pk="#{partie_node['pk']}"])))
-            name = "#{options[:region]}-#{source_type}#{espace_node.(:Nom)}".remove(/\s/)
-            add(
-              AIXM.airspace(
-                source: source(section: 'ENR', position: espace_node.line),
-                name: "#{name} #{partie_node.(:NomUsuel)}".strip,
-                type: target[:type],
-                local_type: target[:local_type]
-              ).tap do |airspace|
-                airspace.geometry = geometry_from(partie_node.(:Contour))
-                if airspace.geometry.point?   # convert point to circle
-                  airspace.geometry = AIXM.geometry(
-                    AIXM.circle(
-                      center_xy: airspace.geometry.segments.first.xy,
-                      radius: POINT_RADIUS
-                    )
-                  )
-                end
-                fail("geometry is not closed") unless airspace.geometry.closed?
-                airspace.add_layer layer_from(volume_node)
-                airspace.layers.first.timetable = timetable_from(volume_node.(:HorCode))
-                airspace.layers.first.remarks = volume_node.(:Activite)
-              end
-            )
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/aipp/regions/LF/dangerous_activities.rb

@@ -1,49 +0,0 @@
-module AIPP
-  module LF
-
-    class DangerousActivities < AIP
-
-      include AIPP::LF::Helpers::Base
-
-      # Map raw activities to type of activity airspace
-      ACTIVITIES = {
-        'AP' => { activity: :other, airspace: :dangerous_activities_area },
-        'Aer' => { activity: :aeromodelling, airspace: :dangerous_activities_area },
-        'Bal' => { activity: :balloon, airspace: :dangerous_activities_area },
-        'Pje' => { activity: :parachuting, airspace: :dangerous_activities_area },
-        'TrPVL' => { activity: :glider_winch, airspace: :dangerous_activities_area },
-        'TrPla' => { activity: :glider_winch, airspace: :dangerous_activities_area },
-        'TrVL' => { activity: :glider_winch, airspace: :dangerous_activities_area },
-        'Vol' => { activity: :acrobatics, airspace: :dangerous_activities_area }
-      }.freeze
-
-      def parse
-        ACTIVITIES.each do |code, type|
-          verbose_info("processing #{code}")
-          cache.espace.css(%Q(Espace[lk^="[LF][#{code} "])).each do |espace_node|
-            partie_node = cache.partie.at_css(%Q(Partie:has(Espace[pk="#{espace_node['pk']}"])))
-            volume_node = cache.volume.at_css(%Q(Volume:has(Partie[pk="#{partie_node['pk']}"])))
-            add(
-              AIXM.airspace(
-                source: source(section: 'ENR', position: espace_node.line),
-                id: espace_node.(:Nom),
-                type: type[:airspace],
-                local_type: code.upcase,
-                name: [espace_node.(:Nom), partie_node.(:NomUsuel)].join(' ')
-              ).tap do |airspace|
-                airspace.geometry = geometry_from partie_node.(:Contour)
-                layer_from(volume_node).then do |layer|
-                  layer.activity = type[:activity]
-                  airspace.add_layer layer
-                end
-                airspace.layers.first.timetable = timetable_from(volume_node.(:HorCode))
-                airspace.layers.first.remarks = volume_node.(:Remarque)
-              end
-            )
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/aipp/regions/LF/designated_points.rb

@@ -1,47 +0,0 @@
-module AIPP
-  module LF
-
-    class DesignatedPoints < AIP
-
-      include AIPP::LF::Helpers::Base
-
-      DEPENDS = %w(aerodromes)
-
-      SOURCE_TYPES = {
-        'VFR' => :vfr_reporting_point,
-        'WPT' => :icao
-      }.freeze
-
-      def parse
-        SOURCE_TYPES.each do |source_type, type|
-          verbose_info("processing #{source_type}")
-          cache.navfix.css(%Q(NavFix[lk^="[LF][#{source_type} "])).each do |navfix_node|
-            ident = navfix_node.(:Ident)
-            add(
-              AIXM.designated_point(
-                source: source(section: 'ENR', position: navfix_node.line),
-                type: type,
-                id: ident.split('-').last.remove(/[^a-z\d]/i),   # only use last segment of ID
-                name: ident,
-                xy: xy_from(navfix_node.(:Geometrie))
-              ).tap do |designated_point|
-                designated_point.remarks = navfix_node.(:Description)
-                if ident.match? /-/
-                  airport = find_by(:airport, id: "LF#{ident.split('-').first}").first
-                  designated_point.airport = airport
-                end
-              end
-            )
-          end
-        end
-        AIXM::Memoize.method :to_uid do
-          aixm.features.find_by(:designated_point).duplicates.each do |duplicates|
-            duplicates.first.name += '/' + duplicates[1..].map(&:name).join('/')
-            aixm.remove_features(duplicates[1..])
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/aipp/regions/LF/helipads.rb

@@ -1,122 +0,0 @@
-module AIPP
-  module LF
-
-    class Helipads < AIP
-
-      include AIPP::LF::Helpers::Base
-      include AIPP::LF::Helpers::UsageLimitation
-      include AIPP::LF::Helpers::Surface
-
-      DEPENDS = %w(aerodromes)
-
-      HOSTILITIES = {
-        'hostile habitée' => 'Zone hostile habitée / hostile populated area',
-        'hostile non habitée' => 'Zone hostile non habitée / hostile unpopulated area',
-        'non hostile' => 'Zone non hostile / non-hostile area'
-      }.freeze
-
-      ELEVATED = {
-        true => 'En terrasse / on deck',
-        false => 'En surface / on ground'
-      }.freeze
-
-      def parse
-        cache.helistation.css(%Q(Helistation[lk^="[LF]"])).each do |helistation_node|
-          # Build airport if necessary
-          next unless limitation_type = LIMITATION_TYPES.fetch(helistation_node.(:Statut))
-          name = helistation_node.(:Nom)
-          airport = find_by(:airport, name: name).first || add(
-            AIXM.airport(
-              source: source(section: 'AD', position: helistation_node.line),
-              organisation: organisation_lf,
-              id: options[:region],
-              name: name,
-              xy: xy_from(helistation_node.(:Geometrie))
-            ).tap do |airport|
-              airport.z = AIXM.z(helistation_node.(:AltitudeFt).to_i, :qnh)
-              airport.add_usage_limitation(type: limitation_type.fetch(:limitation)) do |limitation|
-                limitation.remarks = limitation_type[:remarks]
-                [:private].each do |purpose|   # TODO: check and simplify
-                  limitation.add_condition do |condition|
-                    condition.realm = limitation_type.fetch(:realm)
-                    condition.origin = :any
-                    condition.rule = case
-                      when helistation_node.(:Ifr?) then :ifr_and_vfr
-                      else :vfr
-                    end
-                    condition.purpose = purpose
-                  end
-                end
-              end
-            end
-          )
-# TODO: link to VAC once supported downstream
-#         # Link to VAC
-#         if helistation_node.(:Atlas?)
-#           vac = "VAC-#{airport.id}" if airport.id.match?(/^LF[A-Z]{2}$/)
-#           vac ||= "VACH-H#{airport.name[0, 3].upcase}"
-#           airport.remarks = [
-#             airport.remarks.to_s,
-#             link_to('VAC-HP', url_for(vac))
-#           ].join("\n")
-#         end
-          # Add helipad and FATO
-          airport.add_helipad(
-            AIXM.helipad(
-              name: 'TLOF',
-              xy: xy_from(helistation_node.(:Geometrie))
-            ).tap do |helipad|
-              helipad.z = AIXM.z(helistation_node.(:AltitudeFt).to_i, :qnh)
-              helipad.dimensions = dimensions_from(helistation_node.(:DimTlof))
-            end.tap do |helipad|
-              airport.add_helipad(helipad)
-              helipad.performance_class = performance_class_from(helistation_node.(:ClassePerf))
-              helipad.surface = surface_from(helistation_node)
-              helipad.marking = helistation_node.(:Balisage) unless helistation_node.(:Balisage)&.match?(/^nil$/i)
-              helipad.add_lighting(AIXM.lighting(position: :other)) if helistation_node.(:Nuit?) || helistation_node.(:Balisage)&.match?(/feu/i)
-              helipad.remarks = {
-                'position/positioning' => [
-                  (HOSTILITIES.fetch(helistation_node.(:ZoneHabitee)) if helistation_node.(:ZoneHabitee)),
-                  (ELEVATED.fetch(helistation_node.(:EnTerrasse?)) if helistation_node.(:EnTerrasse)),
-                ].compact.join("\n"),
-                'hauteur/height' => given(helistation_node.(:HauteurFt)) { "#{_1} ft" },
-                'exploitant/operator' => helistation_node.(:Exploitant)
-              }.to_remarks
-              if fato_dimensions = dimensions_from(helistation_node.(:DimFato))
-                AIXM.fato(name: 'FATO').tap do |fato|
-                  fato.dimensions = fato_dimensions
-                  airport.add_fato(fato)
-                  helipad.fato = fato
-                end
-              end
-            end
-          )
-        end
-      end
-
-      private
-
-      def dimensions_from(content)
-        if content
-          dims = content.remove(/[^x\d.,]/i).split(/x/i).map { _1.to_ff.floor }
-          case dims.size
-          when 1
-            AIXM.r(AIXM.d(dims[0], :m))
-          when 2
-            AIXM.r(AIXM.d(dims[0], :m), AIXM.d(dims[1], :m))
-          when 4
-            AIXM.r(AIXM.d(dims.min, :m))
-          else
-            warn("ignoring dimensions `#{content}'", severe: false)
-            nil
-          end
-        end
-      end
-
-      def performance_class_from(content)
-        content.remove(/\d{2,}/).scan(/\d/).map(&:to_i).min&.to_s if content
-      end
-
-    end
-  end
-end

data/lib/aipp/regions/LF/navigational_aids.rb

@@ -1,85 +0,0 @@
-module AIPP
-  module LF
-
-    class NavigationalAids < AIP
-
-      include AIPP::LF::Helpers::Base
-
-      SOURCE_TYPES = {
-        'DME-ATT' => [:dme],
-        'TACAN' => [:tacan],
-        'VOR' => [:vor],
-        'VOR-DME' => [:vor, :dme],
-        'VORTAC' => [:vor, :tacan],
-        'NDB' => [:ndb]
-      }.freeze
-
-      def parse
-        SOURCE_TYPES.each do |source_type, (primary_type, secondary_type)|
-          verbose_info("processing #{source_type}")
-          cache.navfix.css(%Q(NavFix[lk^="[LF][#{source_type} "])).each do |navfix_node|
-            attributes = {
-              source: source(section: 'ENR', position: navfix_node.line),
-              organisation: organisation_lf,
-              id: navfix_node.(:Ident),
-              xy: xy_from(navfix_node.(:Geometrie))
-            }
-            if radionav_node = cache.radionav.at_css(%Q(RadioNav:has(NavFix[pk="#{navfix_node.attr(:pk)}"])))
-              attributes.merge! send(primary_type, radionav_node)
-              add(
-                AIXM.send(primary_type, **attributes).tap do |navigational_aid|
-                  navigational_aid.name = radionav_node.(:NomPhraseo) || radionav_node.(:Station)
-                  navigational_aid.timetable = timetable_from(radionav_node.(:HorCode))
-                  navigational_aid.remarks = {
-                    "location/situation" => radionav_node.(:Situation),
-                    "range/portée" => range_from(radionav_node)
-                  }.to_remarks
-                  navigational_aid.send("associate_#{secondary_type}") if secondary_type
-                end
-              )
-            else
-              verbose_info("skipping incomplete #{source_type} #{attributes[:id]}")
-            end
-          end
-        end
-      end
-
-      private
-
-      def dme(radionav_node)
-        {
-          ghost_f: AIXM.f(radionav_node.(:Frequence).to_f, :mhz),
-          z: AIXM.z(radionav_node.(:AltitudeFt).to_i, :qnh)
-        }
-      end
-      alias_method :tacan, :dme
-
-      def vor(radionav_node)
-        {
-          type: :conventional,
-          north: :magnetic,
-          name: radionav_node.(:Station),
-          f: AIXM.f(radionav_node.(:Frequence).to_f, :mhz),
-          z: AIXM.z(radionav_node.(:AltitudeFt).to_i, :qnh),
-        }
-      end
-
-      def ndb(radionav_node)
-        {
-          type: :en_route,
-          f: AIXM.f(radionav_node.(:Frequence).to_f, :khz),
-          z: AIXM.z(radionav_node.(:AltitudeFt).to_i, :qnh)
-        }
-      end
-
-      def range_from(radionav_node)
-        [
-          radionav_node.(:Portee).blank_to_nil&.concat('NM'),
-          radionav_node.(:FlPorteeVert).blank_to_nil&.prepend('FL'),
-          radionav_node.(:Couverture).blank_to_nil
-        ].compact.join(' / ')
-      end
-
-    end
-  end
-end

data/lib/aipp/regions/LF/obstacles.rb

@@ -1,153 +0,0 @@
-module AIPP
-  module LF
-
-    class Obstacles < AIP
-
-      include AIPP::LF::Helpers::Base
-
-      # Map type descriptions to AIXM types and remarks
-      TYPES = {
-        'Antenne' => [:antenna],
-        'Autre' => [:other],
-        'Bâtiment' => [:building],
-        'Câble' => [:other, 'Cable / Câble'],
-        'Centrale thermique' => [:building, 'Thermal power plant / Centrale thermique'],
-        "Château d'eau" => [:tower, "Water tower / Château d'eau"],
-        'Cheminée' => [:chimney],
-        'Derrick' => [:tower, 'Derrick'],
-        'Eglise' => [:tower, 'Church / Eglise'],
-        'Eolienne' => [:wind_turbine],
-        'Eolienne(s)' => [:wind_turbine],
-        'Grue' => [:tower, 'Crane / Grue'],
-        'Mât' => [:mast],
-        'Phare marin' => [:tower, 'Lighthouse / Phare marin'],
-        'Pile de pont' => [:other, 'Bridge piers / Pile de pont'],
-        'Portique' => [:building, 'Arch / Portique'],
-        'Pylône' => [:mast, 'Pylon / Pylône'],
-        'Silo' => [:tower, 'Silo'],
-        'Terril' => [:other, 'Spoil heap / Teril'],
-        'Torchère' => [:chimney, 'Flare / Torchère'],
-        'Tour' => [:tower],
-        'Treillis métallique' => [:other, 'Metallic grid / Treillis métallique']
-      }.freeze
-
-      def parse
-        if options[:region_options].include? 'lf_obstacles_xlsx'
-          info("reading obstacles from XLSX")
-          @xlsx = read('Obstacles')
-          parse_from_xlsx
-        else
-          parse_from_xml
-        end
-      end
-
-      private
-
-      def parse_from_xlsx
-        # Build obstacles
-        @xlsx.sheet(@xlsx.sheets.find(/^data/i).first).each(
-          name: 'IDENTIFICATEUR',
-          type: 'TYPE',
-          count: 'NOMBRE',
-          longitude: 'LONGITUDE DECIMALE',
-          latitude: 'LATITUDE DECIMALE',
-          elevation: 'ALTITUDE AU SOMMET',
-          height: 'HAUTEUR HORS SOL',
-          height_unit: 'UNITE',
-          horizontal_accuracy: 'PRECISION HORIZONTALE',
-          vertical_accuracy: 'PRECISION VERTICALE',
-          visibility: 'BALISAGE',
-          remarks: 'REMARK',
-          effective_on: 'DATE DE MISE EN VIGUEUR'
-        ).with_index(0) do |row, index|
-          next unless row[:effective_on].to_s.match? /\d{8}/
-          type, type_remarks = TYPES.fetch(row[:type])
-          count = row[:count].to_i
-          obstacle = AIXM.obstacle(
-            source: source(section: 'ENR', position: index),
-            name: row[:name],
-            type: type,
-            xy: AIXM.xy(lat: row[:latitude].to_f, long: row[:longitude].to_f),
-            z: AIXM.z(row[:elevation].to_i, :qnh)
-          ).tap do |obstacle|
-            obstacle.height = AIXM.d(row[:height].to_i, row[:height_unit])
-            if row[:horizontal_accuracy]
-              accuracy = row[:horizontal_accuracy].split
-              obstacle.xy_accuracy = AIXM.d(accuracy.first.to_i, accuracy.last)
-            end
-            if row[:vertical_accuracy]
-              accuracy = row[:horizontal_accuracy].split
-              obstacle.z_accuracy = AIXM.d(accuracy.first.to_i, accuracy.last)
-            end
-            obstacle.marking = row[:visibility].match?(/jour/i)
-            obstacle.lighting = row[:visibility].match?(/nuit/i)
-            obstacle.remarks = {
-              'type' => type_remarks,
-              'number/nombre' => (count if count > 1),
-              'details' => row[:remarks],
-              'effective/mise en vigueur' => (row[:effective_on].to_s.unpack("a4a2a2").join("-") if row[:updated_on])
-            }.to_remarks
-            # Group obstacles
-            if aixm.features.find_by(:obstacle, xy: obstacle.xy).any?
-              warn("duplicate obstacle #{obstacle.name}", severe: false)
-            else
-              if count > 1
-                obstacle_group = AIXM.obstacle_group(
-                  source: obstacle.source,
-                  name: obstacle.name
-                ).tap do |obstacle_group|
-                  obstacle_group.remarks = "#{count} obstacles"
-                end
-                obstacle_group.add_obstacle obstacle
-                add obstacle_group
-              else
-                add obstacle
-              end
-            end
-          end
-        end
-      end
-
-      def parse_from_xml
-        cache.obstacle.css(%Q(Obstacle[lk^="[LF]"])).each do |node|
-          # Build obstacles
-          type, type_remarks = TYPES.fetch(node.(:TypeObst))
-          count = node.(:Combien).to_i
-          obstacle = AIXM.obstacle(
-            source: source(section: 'ENR', position: node.line),
-            name: node.(:NumeroNom),
-            type: type,
-            xy: xy_from(node.(:Geometrie)),
-            z: AIXM.z(node.(:AmslFt).to_i, :qnh)
-          ).tap do |obstacle|
-            obstacle.height = AIXM.d(node.(:AglFt).to_i, :ft)
-            obstacle.marking = node.(:Balisage).match?(/jour/i)
-            obstacle.lighting = node.(:Balisage).match?(/nuit/i)
-            obstacle.remarks = {
-              'type' => type_remarks,
-              'number/nombre' => (count if count > 1)
-            }.to_remarks
-          end
-          # Group obstacles
-          if aixm.features.find_by(:obstacle, xy: obstacle.xy).any?
-            warn("duplicate obstacle #{obstacle.name}", severe: false)
-          else
-            if count > 1
-              obstacle_group = AIXM.obstacle_group(
-                source: obstacle.source,
-                name: obstacle.name
-              ).tap do |obstacle_group|
-                obstacle_group.remarks = "#{count} obstacles"
-              end
-              obstacle_group.add_obstacle obstacle
-              add obstacle_group
-            else
-              add obstacle
-            end
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/aipp/regions/LF/serviced_airspaces.rb

@@ -1,70 +0,0 @@
-module AIPP
-  module LF
-
-    class ServicedAirspaces < AIP
-
-      include AIPP::LF::Helpers::Base
-
-      # Map source types to type and optional local type and skip regexp
-      SOURCE_TYPES = {
-        'FIR' => { type: 'FIR' },
-        'UIR' => { type: 'UIR' },
-        'UTA' => { type: 'UTA' },
-        'CTA' => { type: 'CTA' },
-        'LTA' => { type: 'CTA', local_type: 'LTA' },
-        'TMA' => { type: 'TMA', skip: /geneve/i },   # Geneva listed FYI only
-        'SIV' => { type: 'SECTOR', local_type: 'FIZ/SIV' },   # providing FIS
-        'CTR' => { type: 'CTR' },
-        'RMZ' => { type: 'RAS', local_type: 'RMZ' },
-        'TMZ' => { type: 'RAS', local_type: 'TMZ' },
-        'RMZ-TMZ' => { type: 'RAS', local_type: 'RMZ-TMZ' }
-      }.freeze
-
-      # Map airspace "<type> <name>" to location indicator
-      FIR_LOCATION_INDICATORS = {
-        'BORDEAUX' => 'LFBB',
-        'BREST' => 'LFRR',
-        'MARSEILLE' => 'LFMM',
-        'PARIS' => 'LFFF',
-        'REIMS' => 'LFRR'
-      }.freeze
-
-      def parse
-        SOURCE_TYPES.each do |source_type, target|
-          verbose_info("processing #{source_type}")
-          cache.espace.css(%Q(Espace[lk^="[LF][#{source_type} "])).each do |espace_node|
-            # Skip all delegated airspaces
-            next if espace_node.(:Nom).match? /deleg/i
-            next if (re = target[:skip]) && espace_node.(:Nom).match?(re)
-            # Build airspaces and layers
-            cache.partie.css(%Q(Partie:has(Espace[pk="#{espace_node['pk']}"]))).each do |partie_node|
-              add(
-                AIXM.airspace(
-                  source: source(section: 'ENR', position: espace_node.line),
-                  name: [
-                    espace_node.(:Nom),
-                    partie_node.(:NomPartie).remove(/^\.$/).blank_to_nil
-                  ].compact.join(' '),
-                  type: target[:type],
-                  local_type: target[:local_type]
-                ).tap do |airspace|
-                  airspace.meta = espace_node.attr('pk')
-                  airspace.geometry = geometry_from(partie_node.(:Contour))
-                  fail("geometry is not closed") unless airspace.geometry.closed?
-                  cache.volume.css(%Q(Volume:has(Partie[pk="#{partie_node['pk']}"]))).each do |volume_node|
-                    airspace.add_layer(
-                      layer_from(volume_node).tap do |layer|
-                        layer.location_indicator = FIR_LOCATION_INDICATORS.fetch(airspace.name) if airspace.type == :flight_information_region
-                      end
-                    )
-                  end
-                end
-              )
-            end
-          end
-        end
-      end
-    end
-
-  end
-end