aipp 0.2.6 → 1.0.0

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

@@ -0,0 +1,223 @@
+module AIPP
+  module LF
+
+    class Aerodromes < AIP
+
+      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
+        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(section: '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', url_for("VAC-#{airport.id}"))
+#           ].join("\n")
+            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 = 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 |parser, object, value|
+        throw(:abort) unless coordinate = parser.fixture.dig(object.id, 'xy')
+        lat, long = coordinate.split(/\s+/)
+        AIXM.xy(lat: lat, long: long)
+      end
+
+      patch AIXM::Feature::Airport, :z do |parser, object, value|
+        throw(:abort) unless value.nil?
+        throw(:abort, 'fixture missing') unless elevation = parser.fixture.dig(object.id, 'z')
+        AIXM.z(elevation, :qnh)
+      end
+
+      patch AIXM::Component::Runway, :dimensions do |parser, object, value|
+        throw(:abort) unless value.surface.zero?
+        throw(:abort, 'fixture missing') unless dimensions = parser.fixture.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 |parser, object, value|
+        throw(:abort) unless value.nil?
+        throw(:abort, 'fixture missing') unless coordinate = parser.fixture.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
+end

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

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

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

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