aipp 1.0.0 → 2.0.0

data/lib/aipp/regions/LF/aip/aerodromes.rb

@@ -0,0 +1,220 @@
+module AIPP::LF::AIP
+  class Aerodromes < AIPP::AIP::Parser
+
+    include AIPP::LF::Helpers::Base
+    include AIPP::LF::Helpers::UsageLimitation
+    include AIPP::LF::Helpers::Surface
+
+    APPROACH_LIGHTING_TYPES = {
+      'CAT I' => :cat_1,
+      'CAT II' => :cat_2,
+      'CAT III' => :cat_3,
+      'CAT II-III' => :cat_2_and_3
+    }.freeze
+
+    LIGHTING_POSITIONS = {
+      threshold: 'Thr',
+      touch_down_zone: 'Tdz',
+      center_line: 'Axe',
+      edge: 'Bord',
+      runway_end: 'Fin',
+      stopway_center_line: 'Swy'
+    }.freeze
+
+    LIGHTING_COLORS = {
+      'W' => :white,
+      'R' => :red,
+      'G' => :green,
+      'B' => :blue,
+      'Y' => :yellow
+    }.freeze
+
+    ICAO_LIGHTING_COLORS = {
+      center_line: :white,
+      edge: :white
+    }.freeze
+
+    def parse
+      AIPP.cache.ad.css(%Q(Ad[lk^="[LF]"])).each do |ad_node|
+        # Build airport
+        next unless limitation_type = LIMITATION_TYPES.fetch(ad_node.(:AdStatut))
+        airport = AIXM.airport(
+          source: source(part: 'AD', position: ad_node.line),
+          organisation: organisation_lf,
+          id: id_from(ad_node.(:AdCode)),
+          name: ad_node.(:AdNomComplet),
+          xy: xy_from(ad_node.(:Geometrie))
+        ).tap do |airport|
+          airport.meta = ad_node.attr('pk')
+          airport.z = given(ad_node.(:AdRefAltFt)) { AIXM.z(_1.to_i, :qnh) }
+          airport.declination = ad_node.(:AdMagVar)&.to_f
+          airport.add_usage_limitation(type: limitation_type.fetch(:limitation)) do |limitation|
+            limitation.remarks = limitation_type[:remarks]
+            [
+              (:scheduled if ad_node.(:TfcRegulier?)),
+              (:not_scheduled if ad_node.(:TfcNonRegulier?)),
+              (:private if ad_node.(:TfcPrive?)),
+              (:other unless ad_node.(:TfcRegulier?) || ad_node.(:TfcNonRegulier?) || ad_node.(:TfcPrive?))
+            ].compact.each do |purpose|
+              limitation.add_condition do |condition|
+                condition.realm = limitation_type.fetch(:realm)
+                condition.origin = case
+                  when ad_node.(:TfcIntl?) && ad_node.(:TfcNtl?) then :any
+                  when ad_node.(:TfcIntl?) then :international
+                  when ad_node.(:TfcNtl?) then :national
+                  else :other
+                end
+                condition.rule = case
+                  when ad_node.(:TfcIfr?) && ad_node.(:TfcVfr?) then :ifr_and_vfr
+                  when ad_node.(:TfcIfr?) then :ifr
+                  when ad_node.(:TfcVfr?) then :vfr
+                  else
+                    warn("falling back to VFR rule for `#{airport.id}'", severe: false)
+                    :vfr
+                end
+                condition.purpose = purpose
+              end
+            end
+          end
+# TODO: link to VAC once supported downstream
+#         # Link to VAC
+#         airport.remarks = [
+#           airport.remarks.to_s,
+#           link_to('VAC-AD', origin_for("VAC-#{airport.id}").file)
+#         ].join("\n")
+          AIPP.cache.rwy.css(%Q(Rwy:has(Ad[pk="#{ad_node.attr(:pk)}"]))).each do |rwy_node|
+            add_runway_to(airport, rwy_node)
+          end
+        end
+        add airport
+      end
+    end
+
+    private
+
+    def id_from(content)
+      case content
+        when /^\d{2}$/ then 'LF00' + content   # private aerodromes without official ID
+        else 'LF' + content
+      end
+    end
+
+    def add_runway_to(airport, rwy_node)
+      AIXM.runway(
+        name: rwy_node.(:Rwy)
+      ).tap do |runway|
+        rwylgt_nodes = AIPP.cache.rwylgt.css(%Q(RwyLgt:has(Rwy[pk="#{rwy_node.attr(:pk)}"])))
+        airport.add_runway(runway)
+        runway.dimensions = AIXM.r(AIXM.d(rwy_node.(:Longueur)&.to_i, :m), AIXM.d(rwy_node.(:Largeur)&.to_i, :m))
+        runway.surface = surface_from(rwy_node)
+        runway.forth.geographic_bearing = given(rwy_node.(:OrientationGeo)) { AIXM.a(_1.to_f) }
+        runway.forth.xy = given(rwy_node.(:LatThr1), rwy_node.(:LongThr1)) { AIXM.xy(lat: _1.to_f, long: _2.to_f) }
+        runway.forth.displaced_threshold = given(rwy_node.(:LatDThr1), rwy_node.(:LongDThr1)) { AIXM.xy(lat: _1.to_f, long: _2.to_f) }
+        runway.forth.z = given(rwy_node.(:AltFtDThr1)) { AIXM.z(_1.to_i, :qnh) }
+        runway.forth.z ||= given(rwy_node.(:AltFtThr1)) { AIXM.z(_1.to_i, :qnh) }
+        if rwylgt_node = rwylgt_nodes[0]
+          runway.forth.vasis = vasis_from(rwylgt_node)
+          given(approach_lighting_from(rwylgt_node)) { runway.forth.add_approach_lighting(_1) }
+          LIGHTING_POSITIONS.each_key do |position|
+            given(lighting_from(rwylgt_node, position)) { runway.forth.add_lighting(_1) }
+          end
+        end
+        if rwy_node.(:Rwy).match? '/'
+          runway.back.xy = given(rwy_node.(:LatThr2), rwy_node.(:LongThr2)) { AIXM.xy(lat: _1.to_f, long: _2.to_f) }
+          runway.back.displaced_threshold = given(rwy_node.(:LatDThr2), rwy_node.(:LongDThr2)) { AIXM.xy(lat: _1.to_f, long: _2.to_f) }
+          runway.back.z = given(rwy_node.(:AltFtDThr2)) { AIXM.z(_1.to_i, :qnh) }
+          runway.back.z ||= given(rwy_node.(:AltFtThr2)) { AIXM.z(_1.to_i, :qnh) }
+          if rwylgt_node = rwylgt_nodes[1]
+            runway.back.vasis = vasis_from(rwylgt_node)
+            given(approach_lighting_from(rwylgt_node)) { runway.back.add_approach_lighting(_1) }
+            LIGHTING_POSITIONS.each_key do |position|
+              given(lighting_from(rwylgt_node, position)) { runway.back.add_lighting(_1) }
+            end
+          end
+        end
+      end
+    end
+
+    def vasis_from(rwylgt_node)
+      if rwylgt_node.(:PapiVasis)
+        AIXM.vasis.tap do |vasis|
+          vasis.type = rwylgt_node.(:PapiVasis)
+          vasis.slope_angle = AIXM.a(rwylgt_node.(:PapiVasisPente).to_f)
+          vasis.meht = AIXM.z(rwylgt_node.(:MehtFt).to_i, :qfe)
+        end
+      end
+    end
+
+    def approach_lighting_from(rwylgt_node)
+      if rwylgt_node.(:LgtApchCat)
+        AIXM.approach_lighting(
+          type: APPROACH_LIGHTING_TYPES.fetch(rwylgt_node.(:LgtApchCat) , :other)
+        ).tap do |approach_lighting|
+          approach_lighting.length = AIXM.d(rwylgt_node.(:LgtApchLongueur).to_i, :m) if rwylgt_node.(:LgtApchLongueur)
+          approach_lighting.intensity = rwylgt_node.(:LgtApchIntensite)&.first_match(/LIH/, /LIM/, /LIL/, default: :other)
+          approach_lighting.remarks = {
+            'type' => (rwylgt_node.(:LgtApchCat) if approach_lighting.type == :other),
+            'intensité/intensity' => (rwylgt_node.(:LgtApchIntensite) if approach_lighting.intensity == :other)
+          }.to_remarks
+        end
+      end
+    end
+
+    def lighting_from(rwylgt_node, position)
+      prefix = "Lgt" + LIGHTING_POSITIONS.fetch(position)
+      if rwylgt_node.(:"#{prefix}Couleur") || rwylgt_node.(:"#{prefix}Longueur")
+        AIXM.lighting(position: position).tap do |lighting|
+          couleur, intensite = rwylgt_node.(:"#{prefix}Couleur"), rwylgt_node.(:"#{prefix}Intensite")
+          lighting.intensity = if intensite
+            intensite.first_match(/LIH/, /LIM/, /LIL/, default: :other)
+          elsif couleur
+            couleur.first_match(/LIH/, /LIM/, /LIL/).tap { couleur.remove!(/LIH|LIM|LIL/) }
+          end
+          lighting.color = if couleur
+            if couleur.match? /ICAO|EASA|OACI|AESA/
+              ICAO_LIGHTING_COLORS[position]
+            else
+              couleur.remove(/[^#{LIGHTING_COLORS.keys.join}]/).compact
+              LIGHTING_COLORS.fetch(couleur, :other)
+            end
+          end
+          lighting.description = {
+            'couleur/color' => (rwylgt_node.(:"#{prefix}Couleur") if [nil, :other].include?(lighting.color)),
+            'longueur/length' =>  rwylgt_node.(:"#{prefix}Longueur"),
+            'espace/spacing' => rwylgt_node.(:"#{prefix}Espace")
+          }.to_remarks
+          lighting.remarks = rwylgt_node.(:LgtRem)
+        end
+      end
+    end
+
+    patch AIXM::Feature::Airport, :xy do |object, value|
+      throw(:abort) unless coordinate = AIPP.fixtures.aerodromes.dig(object.id, 'xy')
+      lat, long = coordinate.split(/\s+/)
+      AIXM.xy(lat: lat, long: long)
+    end
+
+    patch AIXM::Feature::Airport, :z do |object, value|
+      throw(:abort) unless value.nil?
+      throw(:abort, 'fixture missing') unless elevation = AIPP.fixtures.aerodromes.dig(object.id, 'z')
+      AIXM.z(elevation, :qnh)
+    end
+
+    patch AIXM::Component::Runway, :dimensions do |object, value|
+      throw(:abort) unless value.surface.zero?
+      throw(:abort, 'fixture missing') unless dimensions = AIPP.fixtures.aerodromes.dig(object.airport.id, object.name, 'dimensions')
+      length, width = dimensions.split(/\D+/)
+      length = length&.match?(/^\d+$/) ? AIXM.d(length.to_i, :m) : value.length
+      width = width&.match?(/^\d+$/) ? AIXM.d(width.to_i, :m) : value.width
+      AIXM.r(length, width).tap { |r| throw(:abort, 'fixture incomplete') if r.surface.zero? }
+    end
+
+    patch AIXM::Component::Runway::Direction, :xy do |object, value|
+      throw(:abort) unless value.nil?
+      throw(:abort, 'fixture missing') unless coordinate = AIPP.fixtures.aerodromes.dig(object.runway.airport.id, object.name.to_s(:runway), 'xy')
+      lat, long = coordinate.split(/\s+/)
+      AIXM.xy(lat: lat, long: long)
+    end
+
+  end
+end

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

@@ -0,0 +1,53 @@
+module AIPP::LF::AIP
+  class DPRAirspaces < AIPP::AIP::Parser
+
+    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}")
+        AIPP.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 = AIPP.cache.partie.at_css(%Q(Partie:has(Espace[pk="#{espace_node['pk']}"])))
+          volume_node = AIPP.cache.volume.at_css(%Q(Volume:has(Partie[pk="#{partie_node['pk']}"])))
+          name = "#{AIPP.options.region}-#{source_type}#{espace_node.(:Nom)}".remove(/\s/)
+          add(
+            AIXM.airspace(
+              source: source(part: '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

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

@@ -0,0 +1,48 @@
+module AIPP::LF::AIP
+  class DangerousActivities < AIPP::AIP::Parser
+
+    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}")
+        AIPP.cache.espace.css(%Q(Espace[lk^="[LF][#{code} "])).each do |espace_node|
+# HACK: Missing partie/volume as of AIRAC 2204 (reported)
+next if espace_node['pk'] == '1360'
+          partie_node = AIPP.cache.partie.at_css(%Q(Partie:has(Espace[pk="#{espace_node['pk']}"])))
+          volume_node = AIPP.cache.volume.at_css(%Q(Volume:has(Partie[pk="#{partie_node['pk']}"])))
+          add(
+            AIXM.airspace(
+              source: source(part: '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

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

@@ -0,0 +1,44 @@
+module AIPP::LF::AIP
+  class DesignatedPoints < AIPP::AIP::Parser
+
+    include AIPP::LF::Helpers::Base
+
+    depends_on :Aerodromes
+
+    SOURCE_TYPES = {
+      'VFR' => :vfr_reporting_point,
+      'WPT' => :icao
+    }.freeze
+
+    def parse
+      SOURCE_TYPES.each do |source_type, type|
+        verbose_info("processing #{source_type}")
+        AIPP.cache.navfix.css(%Q(NavFix[lk^="[LF][#{source_type} "])).each do |navfix_node|
+          ident = navfix_node.(:Ident)
+          add(
+            AIXM.designated_point(
+              source: source(part: '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::Concerns::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

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

@@ -0,0 +1,119 @@
+module AIPP::LF::AIP
+  class Helipads < AIPP::AIP::Parser
+
+    include AIPP::LF::Helpers::Base
+    include AIPP::LF::Helpers::UsageLimitation
+    include AIPP::LF::Helpers::Surface
+
+    depends_on :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
+      AIPP.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(part: 'AD', position: helistation_node.line),
+            organisation: organisation_lf,
+            id: AIPP.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', origin_for(vac).file)
+#         ].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

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

@@ -0,0 +1,82 @@
+module AIPP::LF::AIP
+  class NavigationalAids < AIPP::AIP::Parser
+
+    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}")
+        AIPP.cache.navfix.css(%Q(NavFix[lk^="[LF][#{source_type} "])).each do |navfix_node|
+          attributes = {
+            source: source(part: 'ENR', position: navfix_node.line),
+            organisation: organisation_lf,
+            id: navfix_node.(:Ident),
+            xy: xy_from(navfix_node.(:Geometrie))
+          }
+          if radionav_node = AIPP.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