aipp 0.2.6 → 1.0.0

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

@@ -0,0 +1,122 @@
+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/helpers/base.rb

@@ -5,217 +5,210 @@ module AIPP
 
         using AIXM::Refinements
 
-        # Map border names to OFMX
-        BORDERS = {
-          'franco-allemande' => 'FRANCE_GERMANY',
-          'franco-espagnole' =>  'FRANCE_SPAIN',
-          'franco-italienne' => 'FRANCE_ITALY',
-          'franco-suisse' => 'FRANCE_SWITZERLAND',
-          'franco-luxembourgeoise' => 'FRANCE_LUXEMBOURG',
-          'franco-belge' => 'BELGIUM_FRANCE',
-          'germano-suisse' => 'GERMANY_SWITZERLAND',
-          'hispano-andorrane' => 'ANDORRA_SPAIN',
-          'la côte atlantique française' => 'FRANCE_ATLANTIC_COAST',
-          'côte méditérrannéenne' => 'FRANCE_MEDITERRANEAN_COAST',
-          'limite des eaux territoriales atlantique françaises' => 'FRANCE_ATLANTIC_TERRITORIAL_SEA',
-          'parc national des écrins' => 'FRANCE_ECRINS_NATIONAL_PARK'
-        }.freeze
-
-        # Intersection points between three countries
-        INTERSECTIONS = {
-          'FRANCE_SPAIN|ANDORRA_SPAIN' => AIXM.xy(lat: 42.502720, long: 1.725965),
-          'ANDORRA_SPAIN|FRANCE_SPAIN' => AIXM.xy(lat: 42.603571, long: 1.442681),
-          'FRANCE_SWITZERLAND|FRANCE_ITALY' => AIXM.xy(lat: 45.922701, long: 7.044125),
-          'BELGIUM_FRANCE|FRANCE_LUXEMBOURG' => AIXM.xy(lat: 49.546428, long: 5.818415),
-          'FRANCE_LUXEMBOURG|FRANCE_GERMANY' => AIXM.xy(lat: 49.469438, long: 6.367516),
-          'FRANCE_GERMANY|FRANCE_SWITZERLAND' => AIXM.xy(lat: 47.589831, long: 7.589049),
-          'GERMANY_SWITZERLAND|FRANCE_GERMANY' => AIXM.xy(lat: 47.589831, long: 7.589049)
-        }.freeze
-
-        # Map surface to OFMX composition, preparation and remarks
-        SURFACES = {
-          /^revêtue?$/ => { preparation: :paved },
-          /^non revêtue?$/ => { preparation: :natural },
-          'macadam' => { composition: :macadam },
-          /^bitume ?(traité|psp)?$/ =>  { composition: :bitumen },
-          'ciment' => { composition: :concrete, preparation: :paved },
-          /^b[eéè]ton ?(armé|bitume|bitumineux)?$/ => { composition: :concrete, preparation: :paved },
-          /^béton( de)? ciment$/ => { composition: :concrete, preparation: :paved },
-          'béton herbe' => { composition: :concrete_and_grass },
-          'béton avec résine' => { composition: :concrete, preparation: :paved, remarks: 'Avec résine / with resin' },
-          "béton + asphalte d'étanchéité sablé" => { composition: :concrete_and_asphalt, preparation: :paved, remarks: 'Étanchéité sablé / sandblasted waterproofing' },
-          'béton armé + support bitumastic' => { composition: :concrete, preparation: :paved, remarks: 'Support bitumastic / bitumen support' },
-          /résine (époxy )?su[er] béton/ => { composition: :concrete, preparation: :paved, remarks: 'Avec couche résine / with resin seal coat' },
-          /^(asphalte|tarmac)$/ => { composition: :asphalt, preparation: :paved },
-          'enrobé' => { preparation: :other, remarks: 'Enrobé / coated' },
-          'enrobé anti-kérozène' => { preparation: :other, remarks: 'Enrobé anti-kérozène / anti-kerosene coating' },
-          /^enrobé bitum(e|iné|ineux)$/ => { composition: :bitumen, preparation: :paved, remarks: 'Enrobé / coated' },
-          'enrobé béton' => { composition: :concrete, preparation: :paved, remarks: 'Enrobé / coated' },
-          /^résine( époxy)?$/ => { composition: :other, remarks: 'Résine / resin' },
-          'tole acier larmé' => { composition: :metal, preparation: :grooved },
-          /^(structure métallique|aluminium)$/ => { composition: :metal },
-          'matériaux composites ignifugés' => { composition: :other, remarks: 'Matériaux composites ignifugés / fire resistant mixed materials' },
-          /^(gazon|herbe)$/ => { composition: :grass },
-          'neige' => { composition: :snow },
-          'neige damée' => { composition: :snow, preparation: :rolled }
-        }.freeze
-
-        # Transform French text fragments to English
-        ANGLICISE_MAP = {
-          /[^A-Z0-9 .\-]/ => '',
-          /0(\d)/ => '\1',
-          /(\d)-(\d)/ => '\1.\2',
-          /PARTIE/ => '',
-          /DELEG\./ => 'DELEG ',
-          /FRANCAISE?/ => 'FR',
-          /ANGLAISE?/ => 'UK',
-          /BELGE/ => 'BE',
-          /LUXEMBOURGEOISE?/ => 'LU',
-          /ALLEMANDE?/ => 'DE',
-          /SUISSE/ => 'CH',
-          /ITALIEN(?:NE)?/ => 'IT',
-          /ESPAGNOLE?/ => 'ES',
-          /ANDORRANE?/ => 'AD',
-          /NORD/ => 'N',
-          /EST/ => 'E',
-          /SUD/ => 'S',
-          /OEST/ => 'W',
-          /ANGLO NORMANDES/ => 'ANGLO-NORMANDES',
-          / +/ => ' '
-        }.freeze
+        # Supported version of the XML_SIA database dump
+        VERSION = '5'.freeze
 
-        # Templates
+        # Mandatory Interface
 
-        def organisation_lf
-          @organisation_lf ||= AIXM.organisation(
-            name: 'FRANCE',
-            type: 'S'
-          ).tap do |organisation|
-            organisation.id = 'LF'
+        def setup
+          AIXM.config.voice_channel_separation = :any
+          unless cache.espace
+            xml = read('XML_SIA')
+            %i(Ad Bordure Espace Frequence Helistation NavFix Obstacle Partie RadioNav Rwy RwyLgt Service Volume).each do |section|
+              cache[section.downcase] = xml.css("#{section}S")
+            end
+            warn("XML_SIA database dump version mismatch") unless xml.at_css('SiaExport').attr(:Version) == VERSION
           end
         end
 
-        # Transformations
-
-        def prepare(html:)
-          html.tap do |node|
-            node.css('del, *[class*="AmdtDeletedAIRAC"]').each(&:remove)   # remove deleted entries
+        def url_for(aip_file)
+          sia_date = options[:airac].date.strftime('%d_%^b_%Y')   # 04_JAN_2018
+          xml_date = options[:airac].date.xmlschema               # 2018-01-04
+          sia_url = "https://www.sia.aviation-civile.gouv.fr/dvd/eAIP_#{sia_date}"
+          case aip_file
+          when /^Obstacles$/   # obstacles spreadsheet
+            "#{sia_url}/FRANCE/ObstaclesDataZone1MFRANCE_#{xml_date.remove('-')}.xlsx"
+          when /^VAC\-(\w+)/   # aerodrome VAC PDF
+            "#{sia_url}/Atlas-VAC/PDF_AIPparSSection/VAC/AD/AD-2.#{$1}.pdf"
+          when /^VACH\-(\w+)/   # helipad VAC PDF
+            "#{sia_url}/Atlas-VAC/PDF_AIPparSSection/VACH/AD/AD-3.#{$1}.pdf"
+          when /^[A-Z]+-/   # eAIP HTML page (e.g. ENR-5.5)
+            "#{sia_url}/FRANCE/AIRAC-#{xml_date}/html/eAIP/FR-#{aip_file}-fr-FR.html"
+          else   # SIA XML database dump
+            "XML_SIA_#{xml_date}.xml"
           end
         end
 
-        def anglicise(name:)
-          name&.uptrans&.tap do |string|
-            ANGLICISE_MAP.each do |regexp, replacement|
-              string.gsub!(regexp, replacement)
+        # Templates
+
+        def organisation_lf
+          unless cache.organisation_lf
+            cache.organisation_lf = AIXM.organisation(
+              source: source(position: 1, aip_file: "GEN-3.1"),
+              name: 'FRANCE',
+              type: 'S'
+            ).tap do |organisation|
+              organisation.id = 'LF'
             end
+            add cache.organisation_lf
           end
+          cache.organisation_lf
         end
 
-        # Parsers
-
-        def source(position:, aip_file: nil)
-          aip_file ||= @aip
+        # Parsersettes
+
+        # Build a source string
+        #
+        # @param position [Integer] line on which to find the information
+        # @param section [String] override autodetected section (e.g. "ENR")
+        # @param aip_file [String] override autodetected aip_file
+        # @return [String] source string
+        def source(position:, section: nil, aip_file: nil)
+          aip_file ||= 'XML_SIA'
+          section ||= aip_file.split(/-(?=\d)/).first
           [
             options[:region],
-            aip_file.split('-').first,
+            section,
             aip_file,
             options[:airac].date.xmlschema,
             position
           ].join('|')
         end
 
-        def xy_from(text)
-          parts = text.strip.split(/\s+/)
-          AIXM.xy(lat: parts[0], long: parts[1])
+        # Convert content to boolean
+        #
+        # @param content [String] either "oui" or "non"
+        # @return [Boolean]
+        def b_from(content)
+          case content
+            when 'oui' then true
+            when 'non' then false
+            else fail "`#{content}' is not boolean content"
+          end
         end
 
-        def z_from(limit)
-          case limit
-            when nil then nil
-            when 'SFC' then AIXM::GROUND
-            when 'UNL' then AIXM::UNLIMITED
-            when /(\d+)ftASFC/ then AIXM.z($1.to_i, :qfe)
-            when /(\d+)ftAMSL/ then AIXM.z($1.to_i, :qnh)
-            when /FL(\d+)/ then AIXM.z($1.to_i, :qne)
-            else fail "z `#{limit}' not recognized"
-          end
+        # Build coordinates from content
+        #
+        # @param content [String] source content
+        # @return [AIXM::XY]
+        def xy_from(content)
+          parts = content.split(/[\s,]+/)
+          AIXM.xy(lat: parts[0].to_f, long: parts[1].to_f)
         end
 
-        def d_from(text)
-          case text
-            when nil then nil
-            when /(\d+)(\w+)/ then AIXM.d($1.to_i, $2.to_sym)
-            else fail "d `#{text}' not recognized"
+        # Build altitude/elevation from value and unit
+        #
+        # @param value [String, Numeric, nil] numeric value
+        # @param unit [String] unit like "ft ASFC" or absolute like "SFC"
+        # @return [AIXM::Z]
+        def z_from(value: nil, unit: 'ft ASFC')
+          if value
+            case unit
+              when 'SFC' then AIXM::GROUND
+              when 'UNL' then AIXM::UNLIMITED
+              when 'ft ASFC' then AIXM.z(value.to_i, :qfe)
+              when 'ft AMSL' then AIXM.z(value.to_i, :qnh)
+              when 'FL' then AIXM.z(value.to_i, :qne)
+              else fail "z `#{[value, unit].join(' ')}' not recognized"
+            end
           end
         end
 
-        def elevation_from(text)
-          value, unit = text.strip.split
-          AIXM.z(AIXM.d(value.to_i, unit).to_ft.dist, :qnh)
+        # Build distance from content
+        #
+        # @param content [String] source content
+        # @return [AIXM::D]
+        def d_from(content)
+          parts = content.split(/\s/)
+          AIXM.d(parts[0].to_f, parts[1])
         end
 
-        def layer_from(text_for_limit, text_for_class=nil)
-          above, below = text_for_limit.gsub(/ /, '').split(/\n+/).select(&:blank_to_nil).split { _1.match? '---+' }
-          AIXM.layer(
-            class: text_for_class,
-            vertical_limit: AIXM.vertical_limit(
-              upper_z: z_from(above[0]),
-              max_z: z_from(above[1]),
-              lower_z: z_from(below[0]),
-              min_z: z_from(below[1])
-            )
-          )
-        end
-
-        def geometry_from(text)
+        # Build geometry from content
+        #
+        # @param content [String] source content
+        # @return [AIXM::Component::Geometry]
+        def geometry_from(content)
           AIXM.geometry.tap do |geometry|
             buffer = {}
-            text.gsub(/\s+/, ' ').strip.split(/ - /).append('end').each do |element|
-              case element
-              when /arc (anti-)?horaire .+ sur (\S+) , (\S+)/i
-                geometry.add_segment AIXM.arc(
-                  xy: buffer.delete(:xy),
-                  center_xy: AIXM.xy(lat: $2, long: $3),
-                  clockwise: $1.nil?
-                )
-              when /cercle de ([\d\.]+) (NM|km|m) .+ sur (\S+) , (\S+)/i
-                geometry.add_segment AIXM.circle(
-                  center_xy: AIXM.xy(lat: $3, long: $4),
-                  radius: AIXM.d($1.to_f, $2)
-                )
-              when /end|(\S+) , (\S+)/
-                geometry.add_segment AIXM.point(xy: buffer[:xy]) if buffer.has_key?(:xy)
-                buffer[:xy] = AIXM.xy(lat: $1, long: $2) if $1
-                if border = buffer.delete(:border)
-                  from = border.nearest(xy: geometry.segments.last.xy)
-                  to = border.nearest(xy: buffer[:xy], geometry_index: from.geometry_index)
-                  geometry.add_segments border.segment(from_position: from, to_position: to).map(&:to_point)
-                end
-              when /^frontière ([\w-]+)/i, /^(\D[^(]+)/i
-                border_name = BORDERS.fetch($1.downcase.strip)
-                if borders.has_key? border_name   # border from GeoJSON
-                  buffer[:border] = borders[border_name]
-                else   # named border
-                  buffer[:xy] ||= INTERSECTIONS.fetch("#{buffer[:border_name]}|#{border_name}")
-                  buffer[:border_name] = border_name
-                  if border_name == 'FRANCE_SPAIN'   # specify which part of this split border
-                    border_name += buffer[:xy].lat < 42.55 ? '_EAST' : '_WEST'
-                  end
-                  geometry.add_segment AIXM.border(
-                    xy: buffer.delete(:xy),
-                    name: border_name
+            content.split("\n").each do |element|
+              parts = element.split(',', 3).last.split(/[():,]/)
+              # Write explicit geometry from previous iteration
+              if (bordure_name, xy = buffer.delete(:fnt))
+                border = borders[bordure_name]
+                geometry.add_segments border.segment(
+                  from_position: border.nearest(xy: xy),
+                  to_position: border.nearest(xy: xy_from(parts[0]))
+                ).map(&:to_point)
+              end
+              # Write current iteration
+              geometry.add_segment(
+                case parts[1]
+                when 'grc'
+                  AIXM.point(
+                    xy: xy_from(parts[0])
+                  )
+                when 'rhl'
+                  AIXM.rhumb_line(
+                    xy: xy_from(parts[0])
+                  )
+                when 'cwa', 'cca'
+                  AIXM.arc(
+                    xy: xy_from(parts[0]),
+                    center_xy: xy_from(parts[5]),
+                    clockwise: (parts[1] == 'cwa')
+                  )
+                when 'cir'
+                  AIXM.circle(
+                    center_xy: xy_from(parts[0]),
+                    radius: d_from(parts[3..4].join(' '))
                   )
+                when 'fnt'
+                  bordure = cache.bordure.at_css(%Q(Bordure[pk="#{parts[3]}"]))
+                  bordure_name = bordure.(:Code)
+                  if bordure_name.match? /:/   # explicit geometry
+                    borders[bordure_name] ||= AIPP::Border.from_array([bordure.(:Geometrie).split])
+                    buffer[:fnt] = [bordure_name, xy_from(parts[2])]
+                    AIXM.point(
+                      xy: xy_from(parts[0])
+                    )
+                  else
+                    AIXM.border(   # named border
+                      xy: xy_from(parts[0]),
+                      name: bordure_name
+                    )
+                  end
+                else
+                  fail "geometry `#{parts[1]}' not recognized"
                 end
-              else
-                fail "geometry `#{element}' not recognized"
-              end
+              )
             end
           end
         end
 
-        def timetable_from!(text)
-          if text.gsub!(/^\s*#{AIXM::H_RE}\s*$/, '')
-            AIXM.timetable(code: Regexp.last_match&.to_s&.strip)
+        # Build timetable from content
+        #
+        # @param content [String] source content
+        # @return [AIXM::Component::Timetable]
+        def timetable_from(content)
+          AIXM.timetable(code: content) if AIXM::H_RE.match? content
+        end
+
+        # Build layer from "volume" node
+        #
+        # @param volume_node [Nokogiri::XML::Element] source node
+        # @return [AIXM::Component::Layer]
+        def layer_from(volume_node)
+          AIXM.layer(
+            class: volume_node.(:Classe),
+            vertical_limit: AIXM.vertical_limit(
+              upper_z: z_from(value: volume_node.(:Plafond), unit: volume_node.(:PlafondRefUnite)),
+              max_z: z_from(value: volume_node.(:Plafond2)),
+              lower_z: z_from(value: volume_node.(:Plancher), unit: volume_node.(:PlancherRefUnite)),
+              min_z: z_from(value: volume_node.(:Plancher2))
+            )
+          ).tap do |layer|
+            layer.timetable = timetable_from(volume_node.(:HorCode))
+            layer.remarks = volume_node.(:Remarque)
           end
         end
 

data/lib/aipp/regions/LF/helpers/surface.rb

@@ -0,0 +1,49 @@
+module AIPP
+  module LF
+    module Helpers
+      module Surface
+
+        # Map surface to OFMX composition, preparation and remarks
+        SURFACES = {
+          /^revêtue?$/ => { preparation: :paved },
+          /^non revêtue?$/ => { preparation: :natural },
+          'macadam' => { composition: :macadam },
+          /^bitume ?(traité|psp)?$/ =>  { composition: :bitumen },
+          'ciment' => { composition: :concrete, preparation: :paved },
+          /^b[eéè]ton ?(armé|bitume|bitumeux|bitumineux)?$/ => { composition: :concrete, preparation: :paved },
+          /^béton( de)? ciment$/ => { composition: :concrete, preparation: :paved },
+          'béton herbe' => { composition: :concrete_and_grass },
+          'béton avec résine' => { composition: :concrete, preparation: :paved, remarks: 'Avec résine / with resin' },
+          "béton + asphalte d'étanchéité sablé" => { composition: :concrete_and_asphalt, preparation: :paved, remarks: 'Étanchéité sablé / sandblasted waterproofing' },
+          'béton armé + support bitumastic' => { composition: :concrete, preparation: :paved, remarks: 'Support bitumastic / bitumen support' },
+          /résine (époxy )?su[er] béton/ => { composition: :concrete, preparation: :paved, remarks: 'Avec couche résine / with resin seal coat' },
+          /^(asphalte|tarmac)$/ => { composition: :asphalt, preparation: :paved },
+          'enrobé' => { preparation: :other, remarks: 'Enrobé / coated' },
+          'enrobé anti-kérozène' => { preparation: :other, remarks: 'Enrobé anti-kérozène / anti-kerosene coating' },
+          /^enrobé bitum(e|iné|ineux)$/ => { composition: :bitumen, preparation: :paved, remarks: 'Enrobé / coated' },
+          'enrobé béton' => { composition: :concrete, preparation: :paved, remarks: 'Enrobé / coated' },
+          /^résine( époxy)?$/ => { composition: :other, remarks: 'Résine / resin' },
+          'tole acier larmé' => { composition: :metal, preparation: :grooved },
+          /^(structure métallique|structure et caillebotis métallique|aluminium)$/ => { composition: :metal },
+          'matériaux composites ignifugés' => { composition: :other, remarks: 'Matériaux composites ignifugés / fire resistant mixed materials' },
+          /^(gazon|herbe)$/ => { composition: :grass },
+          'neige' => { composition: :snow },
+          'neige damée' => { composition: :snow, preparation: :rolled },
+          'surface en bois' => { composition: :wood }
+        }.freeze
+
+        def surface_from(node)
+          AIXM.surface.tap do |surface|
+            SURFACES.metch(node.(:Revetement), default: {}).tap do |surface_attributes|
+              surface.composition = surface_attributes[:composition]
+              surface.preparation = surface_attributes[:preparation]
+              surface.remarks = surface_attributes[:remarks]
+            end
+            surface.pcn = node.(:Resistance)&.first_match(AIXM::PCN_RE)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/aipp/regions/LF/helpers/usage_limitation.rb

@@ -0,0 +1,20 @@
+module AIPP
+  module LF
+    module Helpers
+      module UsageLimitation
+
+        # Map limitation type descriptions to AIXM limitation, realm and remarks
+        LIMITATION_TYPES = {
+          'OFF' => nil,   # skip decommissioned aerodromes/helistations
+          'CAP' => { limitation: :permitted, realm: :civilian },
+          'ADM' => { limitation: :permitted, realm: :other, remarks: "Goverment ACFT only / Réservé aux ACFT de l'État" },
+          'MIL' => { limitation: :permitted, realm: :military },
+          'PRV' => { limitation: :reservation_required, realm: :civilian },
+          'RST' => { limitation: :reservation_required, realm: :civilian },
+          'TPD' => { limitation: :reservation_required, realm: :civilian }
+        }.freeze
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+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