aipp 0.2.4 → 1.0.0

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