aixm 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da3e3c10902d2c8b47bea41e1056a5447890e1ebeb9d7fb651115cc894f10067
-  data.tar.gz: dc2edb38a94804aa7c2c89d2cfcad6872a909598e77ac266fafebf2c39f7deb0
+  metadata.gz: d3f7a1a1f47a40725a1f7444d97ca6f11acf3c1805d3d2521d9c79c72494abe5
+  data.tar.gz: a45d00f0667b808e4e44f5a065392c4d0f6a00fbcd7e085c8bab072288fcdf7b
 SHA512:
-  metadata.gz: 70a1af692e7141c60c49b3c2426be8037f030acc7808a3ec12029bc8df5bc62681396eb3b8e42add5aff92c10d010156a4cc920f8febf0b70a576a1fb5bd7ac2
-  data.tar.gz: c5dc5a92ebef4b7dea61928c794dd2d38c64c9d6a83fc305cb6b6105dff3adb7cb34b4c5eccb95501a14dbb89317c311924c5928a84fa333c165112cda63f820
+  metadata.gz: e58d749b2c1face5c6ec67c1e0f23e5fba2ebca6e3d111cc5075ce561c6c7d6b022585f2cdf0ace8e9320f7b1684385f7ab7bb7c1ca80ecf485afb19e7257cba
+  data.tar.gz: 5888395288986381ed501d7b7a488729e6be98dc65ed1e77c1bb9522022b95cc7d62f13031272edb86c86a3ce41c301917c30e5cce1e88756d88688b8ca2bd87

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 0.3.2
+
+#### Additions
+* Obstacle and obstacle group features
+* `AIXM::D` (distance)
+
+#### Breaking Changes
+* All distances (circle geometry radius, helipad and runway length/width) must
+  be `AIXM::D`.
+* `AIXM::XY#distance` now returns `AIXM::D`
+* Removed obsolete refinement `Float#to_km` (use `AIXM::D#to_km` instead)
+
 ## 0.3.1
 
 #### Additions
@@ -9,7 +21,7 @@
 #### Breaking Changes
 * Renamed `Airport#code` to `Airport#id`
 * Renamed `Airspace#short_name` to `Airspace#local_type`
-* Moved `region` attribute from features to Document 
+* Moved `region` attribute from features to Document
 
 #### Changes
 * Be more permissive on `Airport#id` in order to accomodate generated codes
@@ -27,7 +39,7 @@
 * Removed `Array#to_digest`
 * Removed `Document#complete?`
 * Renamed Schedule to Timetable
-* Timetable and remarks moved from Airspace to to Layer (formerly known as class layer)
+* Timetable and remarks moved from Airspace to Layer (formerly known as class layer)
 
 #### Additions
 * Organization and Unit features
@@ -69,7 +81,7 @@
 * Symbols such as `:qnh`, `:ofm` or `:mhz` are downcased now
 
 #### Additions
-* Frequency
+* `AIXM::F` (frequency)
 * Navigational aids features
 * `AIXM::Z#qfe?` and friends
 
@@ -111,11 +123,11 @@
 ## 0.1.0
 
 #### Initial Implementation
-* XY Coordinate
-* Z Altitude
+* `AIXM::XY` (coordinates)
+* `AIXM::Z` (altitude or elevation)
 * AIXM-Snapshot 4.5 Document
 * Airspace feature
-* Vertical Limits
+* Vertical limits
 * Geometry
   * Point
   * Arc

data/README.md

@@ -74,6 +74,7 @@ AIXM.schema(:version)   # => 0
 * [Document](http://www.rubydoc.info/gems/aixm/AIXM/Document.html)
 * [XY (longitude and latitude)](http://www.rubydoc.info/gems/aixm/AIXM/XY.html)
 * [Z (height, elevation or altitude)](http://www.rubydoc.info/gems/aixm/AIXM/Z.html)
+* [D (distance or length)](http://www.rubydoc.info/gems/aixm/AIXM/D.html)
 * [F (frequency)](http://www.rubydoc.info/gems/aixm/AIXM/F.html)
 
 ### Features
@@ -88,6 +89,7 @@ AIXM.schema(:version)   # => 0
   * [NDB](http://www.rubydoc.info/gems/aixm/AIXM/Feature/NDB.html)
   * [TACAN](http://www.rubydoc.info/gems/aixm/AIXM/Feature/TACAN.html)
   * [VOR](http://www.rubydoc.info/gems/aixm/AIXM/Feature/VOR.html)
+* [Obstacle and obstacle group](http://www.rubydoc.info/gems/aixm/AIXM/Feature/Obstacle.html)
 
 ### Components
 * [Service](http://www.rubydoc.info/gems/aixm/AIXM/Component/Service.html)

data/lib/aixm.rb

@@ -14,6 +14,7 @@ require_relative 'aixm/errors'
 require_relative 'aixm/document'
 require_relative 'aixm/xy'
 require_relative 'aixm/z'
+require_relative 'aixm/d'
 require_relative 'aixm/f'
 
 require_relative 'aixm/component'
@@ -42,5 +43,7 @@ require_relative 'aixm/feature/navigational_aid/marker'
 require_relative 'aixm/feature/navigational_aid/ndb'
 require_relative 'aixm/feature/navigational_aid/tacan'
 require_relative 'aixm/feature/navigational_aid/vor'
+require_relative 'aixm/feature/obstacle'
+require_relative 'aixm/feature/obstacle_group'
 
 require_relative 'aixm/shortcuts'

data/lib/aixm/component/geometry/circle.rb

@@ -4,12 +4,12 @@ module AIXM
   class Component
     class Geometry
 
-      # Circles are defined by a {#center_xy} and a {#radius} in kilometers.
+      # Circles are defined by a {#center_xy} and a {#radius}.
       #
       # ===Cheat Sheet in Pseudo Code:
       #   circle = AIXM.circle(
       #     center_xy: AIXM.xy
-      #     radius: Numeric   # kilometers
+      #     radius: AIXM.d
       #   )
       #
       # @see https://github.com/openflightmaps/ofmx/wiki/Airspace#circle
@@ -17,7 +17,7 @@ module AIXM
         # @return [AIXM::XY] center point
         attr_reader :center_xy
 
-        # @return [Integer] circle radius
+        # @return [AIXM::D] circle radius
         attr_reader :radius
 
         def initialize(center_xy:, radius:)
@@ -35,8 +35,8 @@ module AIXM
         end
 
         def radius=(value)
-          fail(ArgumentError, "invalid radius") unless value.is_a?(Numeric) && value > 0
-          @radius = value.to_f
+          fail(ArgumentError, "invalid radius") unless value.is_a?(AIXM::D) && value.dist > 0
+          @radius = value
         end
 
         # @return [String] AIXM or OFMX markup
@@ -58,7 +58,7 @@ module AIXM
         # and on the circumference of the circle.
         def north_xy
           AIXM.xy(
-            lat: center_xy.lat + radius.to_f / (AIXM::XY::EARTH_RADIUS / 1000) * 180 / Math::PI,
+            lat: center_xy.lat + radius.to_km.dist / (AIXM::XY::EARTH_RADIUS / 1000) * 180 / Math::PI,
             long: center_xy.long
           )
         end

data/lib/aixm/component/helipad.rb

@@ -11,8 +11,8 @@ module AIXM
     #   )
     #   helipad.xy = AIXM.xy
     #   helipad.z = AIXM.z or nil
-    #   helipad.length = Integer or nil   # meters
-    #   helipad.width = Integer or nil    # meters
+    #   helipad.length = AIXM.d or nil   # must use same unit as width
+    #   helipad.width = AIXM.d or nil    # must use same unit as length
     #   helipad.composition = COMPOSITIONS or nil
     #   helipad.status = STATUSES or nil
     #   helipad.remarks = String or nil
@@ -50,13 +50,13 @@ module AIXM
       # @return [AIXM::XY] center point
       attr_reader :xy
 
-      # @return [AIXM:Z, nil] elevation in +:qnh+
+      # @return [AIXM::Z, nil] elevation in +:qnh+
       attr_reader :z
 
-      # @return [Integer, nil] length in meters
+      # @return [AIXM::D, nil] length
       attr_reader :length
 
-      # @return [Integer, nil] width in meters
+      # @return [AIXM::D, nil] width
       attr_reader :width
 
       # @return [Symbol, nil] composition of the surface (see {COMPOSITIONS})
@@ -99,13 +99,19 @@ module AIXM
       end
 
       def length=(value)
-        fail(ArgumentError, "invalid length") unless value.nil? || (value.is_a?(Numeric) && value > 0)
-        @length = value.nil? ? nil : value.to_i
+        @length = if value
+          fail(ArgumentError, "invalid length") unless value.is_a?(AIXM::D) && value.dist > 0
+          fail(ArgumentError, "invalid length unit") if width && width.unit != value.unit
+          @length = value
+        end
       end
 
       def width=(value)
-        fail(ArgumentError, "invalid width") unless value.nil? || (value.is_a?(Numeric)  && value > 0)
-        @width = value.nil? ? nil : value.to_i
+        @width = if value
+          fail(ArgumentError, "invalid width") unless value.is_a?(AIXM::D)  && value.dist > 0
+          fail(ArgumentError, "invalid width unit") if length && length.unit != value.unit
+          @width = value
+        end
       end
 
       def composition=(value)
@@ -141,9 +147,10 @@ module AIXM
             tla.valElev(z.alt)
             tla.uomDistVer(z.unit.upcase.to_s)
           end
-          tla.valLen(length) if length
-          tla.valWid(width) if width
-          tla.uomDim('M') if length || width
+          tla.valLen(length.dist.trim) if length
+          tla.valWid(width.dist.trim) if width
+          tla.uomDim(length.unit.to_s.upcase) if length
+          tla.uomDim(width.unit.to_s.upcase) if width && !length
           tla.codeComposition(COMPOSITIONS.key(composition).to_s) if composition
           tla.codeSts(STATUSES.key(status).to_s) if status
           tla.txtRmk(remarks) if remarks

data/lib/aixm/component/runway.rb

@@ -16,8 +16,8 @@ module AIXM
     #   runway = AIXM.runway(
     #     name: String
     #   )
-    #   runway.length = Integer or nil   # meters
-    #   runway.width = Integer or nil    # meters
+    #   runway.length = AIXM.d or nil   # must use same unit as width
+    #   runway.width = AIXM.d or nil    # must use same unit as length
     #   runway.composition = COMPOSITIONS or nil
     #   runway.status = STATUSES or nil
     #   runway.remarks = String or nil
@@ -25,7 +25,7 @@ module AIXM
     #   runway.forth.geographic_orientation = Integer or nil   # degrees
     #   runway.forth.xy = AIXM.xy
     #   runway.forth.z = AIXM.z or nil
-    #   runway.forth.displaced_threshold = Integer or nil   # meters
+    #   runway.forth.displaced_threshold = AIXM.xy or AIXM.d or nil
     #   runway.forth.remarks = String or nil
     #
     # @example Bidirectional runway
@@ -73,10 +73,10 @@ module AIXM
       # @return [String] full name of runway (e.g. "12/30" or "16L/34R")
       attr_reader :name
 
-      # @return [Integer, nil] length in meters
+      # @return [AIXM::D, nil] length
       attr_reader :length
 
-      # @return [Integer, nil] width in meters
+      # @return [AIXM::D, nil] width
       attr_reader :width
 
       # @return [Symbol, nil] composition of the surface (see {COMPOSITIONS})
@@ -119,13 +119,19 @@ module AIXM
       end
 
       def length=(value)
-        fail(ArgumentError, "invalid length") unless value.nil? || (value.is_a?(Numeric) && value > 0)
-        @length = value.nil? ? nil : value.to_i
+        @length = if value
+          fail(ArgumentError, "invalid length") unless value.is_a?(AIXM::D) && value.dist > 0
+          fail(ArgumentError, "invalid length unit") if width && width.unit != value.unit
+          @length = value
+        end
       end
 
       def width=(value)
-        fail(ArgumentError, "invalid width") unless value.nil? || (value.is_a?(Numeric)  && value > 0)
-        @width = value.nil? ? nil : value.to_i
+        @width = if value
+          fail(ArgumentError, "invalid width") unless value.is_a?(AIXM::D)  && value.dist > 0
+          fail(ArgumentError, "invalid width unit") if length && length.unit != value.unit
+          @width = value
+        end
       end
 
       def composition=(value)
@@ -154,9 +160,10 @@ module AIXM
         builder = Builder::XmlMarkup.new(indent: 2)
         builder.Rwy do |rwy|
           rwy << to_uid.indent(2)
-          rwy.valLen(length) if length
-          rwy.valWid(width) if width
-          rwy.uomDimRwy('M') if length || width
+          rwy.valLen(length.dist.trim) if length
+          rwy.valWid(width.dist.trim) if width
+          rwy.uomDimRwy(length.unit.to_s.upcase) if length
+          rwy.uomDimRwy(width.unit.to_s.upcase) if width && !length
           rwy.codeComposition(COMPOSITIONS.key(composition).to_s) if composition
           rwy.codeSts(STATUSES.key(status).to_s) if status
           rwy.txtRmk(remarks) if remarks
@@ -188,9 +195,9 @@ module AIXM
         # @return [AIXM::Z, nil] elevation of the touch down zone in +qnh+
         attr_reader :z
 
-        # @return [AIXM::XY, Integer, nil] displaced threshold point either as
-        #   coordinates (AIXM::XY) or distance (Integer) in meters from the
-        #   beginning point
+        # @return [AIXM::XY, AIXM::D, nil] displaced threshold point either as
+        #   coordinates (AIXM::XY) or distance (AIXM::D) from the beginning
+        #   point
         attr_reader :displaced_threshold
 
         # @return [String, nil] free text remarks
@@ -234,11 +241,16 @@ module AIXM
         end
 
         def displaced_threshold=(value)
-          @displaced_threshold = case value
-            when AIXM::XY then @xy.distance(value).to_i
-            when Numeric then value.to_i
-            when NilClass then nil
-            else fail(ArgumentError, "invalid displaced threshold")
+          case value
+          when AIXM::XY
+            @displaced_threshold = @xy.distance(value)
+          when AIXM::D
+            fail(ArgumentError, "invalid displaced threshold") unless value.dist > 0
+            @displaced_threshold = value
+          when NilClass
+            @displaced_threshold = nil
+          else
+            fail(ArgumentError, "invalid displaced threshold")
           end
         end
 
@@ -281,8 +293,8 @@ module AIXM
                 rdd_uid.codeType('DPLM')
                 rdd_uid.codeDayPeriod('A')
               end
-              rdd.valDist(displaced_threshold)
-              rdd.uomDist('M')
+              rdd.valDist(displaced_threshold.dist.trim)
+              rdd.uomDist(displaced_threshold.unit.to_s.upcase)
               rdd.txtRmk(remarks) if remarks
             end
           end

data/lib/aixm/d.rb

@@ -0,0 +1,66 @@
+using AIXM::Refinements
+
+module AIXM
+
+  # Distance or length
+  #
+  # @example
+  #   AIXM.d(123, :m)
+  class D
+    include Comparable
+
+    UNITS = {
+      ft: { km: 0.0003048, m: 0.3048, nm: 0.000164578833554 },
+      km: { ft: 3280.839895, m: 1000, nm: 0.539956803 },
+      m: { ft: 3.280839895, km: 0.001, nm: 0.000539956803 },
+      nm: { ft: 6076.11548554, km: 1.852, m: 1852 }
+    }.freeze
+
+    # @return [Float] distance
+    attr_reader :dist
+
+    # @return [Symbol] unit (see {UNITS})
+    attr_reader :unit
+
+    def initialize(dist, unit)
+      self.dist, self.unit = dist, unit
+    end
+
+    # @return [String]
+    def inspect
+      %Q(#<#{self.class} #{to_s}>)
+    end
+
+    # @return [String] human readable representation (e.g. "123 m")
+    def to_s
+      [dist, unit].join(' ')
+    end
+
+    def dist=(value)
+      fail(ArgumentError, "invalid dist") unless value.is_a?(Numeric) && value >= 0
+      @dist = value.to_f
+    end
+
+    def unit=(value)
+      fail(ArgumentError, "invalid unit") unless value.respond_to? :to_sym
+      @unit = value.to_sym.downcase
+      fail(ArgumentError, "invalid unit") unless UNITS.has_key? @unit
+    end
+
+    def <=>(other)
+      to_m.dist <=> other.to_m.dist
+    end
+
+    # @!method to_ft
+    # @!method to_km
+    # @!method to_m
+    # @!method to_nm
+    # @return [AIXM::d] convert distance
+    UNITS.each_key do |target_unit|
+      define_method "to_#{target_unit}" do
+        return self if unit == target_unit
+        self.class.new((dist * UNITS[unit][target_unit]).round(8), target_unit)
+      end
+    end
+  end
+end

data/lib/aixm/document.rb

@@ -53,11 +53,11 @@ module AIXM
     end
 
     def created_at=(value)
-      @created_at = parse_time(value) || effective_at || Time.now
+      @created_at = value&.to_time || effective_at || Time.now
     end
 
     def effective_at=(value)
-      @effective_at = parse_time(value) || created_at || Time.now
+      @effective_at = value&.to_time || created_at || Time.now
     end
 
     # Validate the generated AIXM or OFMX atainst it's XSD.
@@ -96,17 +96,5 @@ module AIXM
       end
     end
 
-    private
-
-    def parse_time(value)
-      case value
-        when String then Time.parse(value)
-        when Date then value.to_time
-        when Time then value
-        when nil then nil
-        else fail(ArgumentError, "invalid date or time")
-      end
-    end
-
   end
 end

data/lib/aixm/feature/airport.rb

@@ -125,6 +125,7 @@ module AIXM
       # however, this may be overridden by setting an alternative value, most
       # notably +:landing_site+.
       #
+      # @!attribute type
       # @return [Symbol] type of airport (see {TYPES})
       def type
         @type = case

data/lib/aixm/feature/obstacle.rb

@@ -0,0 +1,288 @@
+using AIXM::Refinements
+
+module AIXM
+  class Feature
+
+    # Obstacles are individual objects described as cylindrical volume with
+    # circular base and height.
+    #
+    # ===Cheat Sheet in Pseudo Code:
+    #   obstacle = AIXM.obstacle(
+    #     source: String or nil
+    #     name: String or nil
+    #     type: TYPES
+    #     xy: AIXM.xy
+    #     radius: AIXM.d
+    #     z: AIXM.z
+    #   )
+    #   obstacle.lighting = true or false (default for AIXM) or nil (means: unknown, default for OFMX)
+    #   obstacle.lighting_remarks = String or nil
+    #   obstacle.marking = true or false or nil (means: unknown, default)
+    #   obstacle.marking_remarks = String or nil
+    #   obstacle.height = AIXM.d or nil
+    #   obstacle.xy_accuracy = AIXM.d or nil
+    #   obstacle.z_accuracy = AIXM.d or nil
+    #   obstacle.height_accurate = true or false or nil (means: unknown, default)
+    #   obstacle.valid_from = Time or Date or String or nil
+    #   obstacle.valid_until = Time or Date or String or nil
+    #   obstacle.remarks = String or nil
+    #
+    # @see https://github.com/openflightmaps/ofmx/wiki/Obstacle
+    class Obstacle < Feature
+      public_class_method :new
+
+      TYPES = {
+        ANTENNA: :antenna,
+        BUILDING: :building,
+        CHIMNEY: :chimney,
+        CRANE: :crane,
+        MAST: :mast,
+        TOWER: :tower,
+        WINDTURBINE: :wind_turbine,
+        OTHER: :other   # specify in remarks
+      }.freeze
+
+      # @return [String] full name
+      attr_reader :name
+
+      # @return [Symbol] type of obstacle
+      attr_reader :type
+
+      # @return [AIXM::XY] circular base center point
+      attr_reader :xy
+
+      # @return [AIXM::D] circular base radius
+      attr_reader :radius
+
+      # @return [AIXM::Z] elevation of the top point in +:qnh+
+      attr_reader :z
+
+      # @return [Boolean, nil] lighting (e.g. strobes)
+      #   true => lighting present, false => no lighting, nil => unknown
+      attr_reader :lighting
+
+      # @return [String, nil] detailed description of the lighting
+      attr_reader :lighting_remarks
+
+      # @return [Boolean, nil] marking (e.g. red/white paint)
+      #  true => marking present, false => no marking, nil => unknown
+      attr_reader :marking
+
+      # @return [String, nil] detailed description of the marking
+      attr_reader :marking_remarks
+
+      # @return [AIXM::D, nil] height from ground to top point
+      attr_reader :height
+
+      # @return [AIXM::D, nil] margin of error for circular base center point
+      attr_reader :xy_accuracy
+
+      # @return [AIXM::D, nil] margin of error for top point
+      attr_reader :z_accuracy
+
+      # @return [Boolean, nil] height accuracy
+      #   true => height measured, false => height estimated, nil => unknown
+      attr_reader :height_accurate
+
+      # @return [Time, Date, String, nil] effective after this point in time
+      attr_reader :valid_from
+
+      # @return [Time, Date, String, nil] effective until this point in time
+      attr_reader :valid_until
+
+      # @return [String, nil] free text remarks
+      attr_reader :remarks
+
+      def initialize(source: nil, name: nil, type:, xy:, radius:, z:)
+        super(source: source)
+        self.name, self.type, self.xy, self.radius, self.z = name, type, xy, radius, z
+        @lighting = @marking = @height_accurate = false
+      end
+
+      # @return [String]
+      def inspect
+        %Q(#<#{self.class} xy="#{xy.to_s}" type=#{type.inspect}>)
+      end
+
+      def name=(value)
+        fail(ArgumentError, "invalid name") unless value.nil? || value.is_a?(String)
+        @name = value&.uptrans
+      end
+
+      def type=(value)
+        @type = TYPES.lookup(value&.to_s&.to_sym, nil) || fail(ArgumentError, "invalid type")
+      end
+
+      def xy=(value)
+        fail(ArgumentError, "invalid xy") unless value.is_a? AIXM::XY
+        @xy = value
+      end
+
+      def radius=(value)
+        fail(ArgumentError, "invalid radius") unless value.is_a?(AIXM::D) && value.dist > 0
+        @radius = value
+      end
+
+      def z=(value)
+        fail(ArgumentError, "invalid z") unless value.is_a?(AIXM::Z) && value.qnh?
+        @z = value
+      end
+
+      def lighting=(value)
+        fail(ArgumentError, "invalid lighting") unless [true, false, nil].include? value
+        @lighting = value
+      end
+
+      def lighting_remarks=(value)
+        @lighting_remarks = value&.to_s
+      end
+
+      def marking=(value)
+        fail(ArgumentError, "invalid marking") unless [true, false, nil].include? value
+        @marking = value
+      end
+
+      def marking_remarks=(value)
+        @marking_remarks = value&.to_s
+      end
+
+      def height=(value)
+        fail(ArgumentError, "invalid height") unless value.nil? || (value.is_a?(AIXM::D) && value.dist > 0)
+        @height = value
+      end
+
+      def xy_accuracy=(value)
+        fail(ArgumentError, "invalid xy accuracy") unless value.nil? || value.is_a?(AIXM::D)
+        @xy_accuracy = value
+      end
+
+      def z_accuracy=(value)
+        fail(ArgumentError, "invalid z accuracy") unless value.nil? || value.is_a?(AIXM::D)
+        @z_accuracy = value
+      end
+
+      def height_accurate=(value)
+        fail(ArgumentError, "invalid height accurate") unless [true, false, nil].include? value
+        @height_accurate = value
+      end
+
+      def valid_from=(value)
+        @valid_from = value&.to_time
+      end
+
+      def valid_until=(value)
+        @valid_until = value&.to_time
+      end
+
+      def remarks=(value)
+        @remarks = value&.to_s
+      end
+
+      # @return [Boolean] estimation whether one obstacle (e.g. single tree) or
+      #    a cluster of obstacles (e.g. a few trees)
+      def clustered?
+        height && radius > height
+      end
+
+      # @return [Boolean] whether part of an obstacle group
+      def grouped?
+        respond_to? :group
+      end
+
+      # @return [String] UID markup
+      def to_uid(as: :ObsUid)
+        builder = Builder::XmlMarkup.new(indent: 2)
+        builder.tag!(as) do |tag|
+          tag.geoLat((xy.lat(AIXM.schema)))
+          tag.geoLong((xy.long(AIXM.schema)))
+        end
+      end
+
+      # @return [String] AIXM or OFMX markup
+      def to_xml
+        builder = Builder::XmlMarkup.new(indent: 2)
+        builder.comment! "Obstacle: [#{type}] #{xy.to_s} #{name}".strip
+        builder.Obs({ source: ((source || (group.source if grouped?)) if AIXM.ofmx?) }.compact) do |obs|
+          obs << to_uid.indent(2)
+          obs.txtName(name) if name
+          if AIXM.ofmx?
+            obs.codeType(TYPES.key(type).to_s)
+          else
+            obs.txtDescrType(TYPES.key(type).to_s)
+            obs.codeGroup(grouped? || clustered? ? 'Y' : 'N')
+          end
+          if AIXM.ofmx?
+            obs.codeLgt(lighting ? 'Y' : 'N') unless lighting.nil?
+            obs.codeMarking(marking ? 'Y' : 'N') unless marking.nil?
+          else
+            obs.codeLgt(lighting ? 'Y' : 'N')
+          end
+          obs.txtDescrLgt(lighting_remarks) if lighting_remarks
+          obs.txtDescrMarking(marking_remarks) if marking_remarks
+          obs.codeDatum('WGE')
+          if xy_accuracy
+            obs.valGeoAccuracy(xy_accuracy.dist.trim)
+            obs.uomGeoAccuracy(xy_accuracy.unit.upcase.to_s)
+          end
+          obs.valElev(z.alt)
+          obs.valElevAccuracy(z_accuracy.to_ft.dist.round) if z_accuracy
+          obs.valHgt(height.to_ft.dist.round) if height
+          if AIXM.ofmx? && !height_accurate.nil?
+            obs.codeHgtAccuracy(height_accurate ? 'Y' : 'N')
+          end
+          obs.uomDistVer('FT')
+          if AIXM.ofmx?
+            obs.valRadius(radius.dist.trim)
+            obs.uomRadius(radius.unit.upcase.to_s)
+            if grouped?
+              obs.codeGroupId(group.id)
+              obs.txtGroupName(group.name) if group.name
+              if linked?
+                obs << linked_to.to_uid(as: :ObsUidLink).indent(2)
+                obs.codeLinkType(AIXM::Feature::ObstacleGroup::LINK_TYPES.key(link_type).to_s)
+              end
+            end
+            obs.datetimeValidWef(valid_from.xmlschema) if valid_from
+            obs.datetimeValidTil(valid_until.xmlschema) if valid_until
+          end
+          obs.txtRmk(remarks) if remarks
+        end
+      end
+
+      # Extensions used by ObstacleGroup feature
+      module Grouped
+        # @return [AIXM::Feature::ObstacleGroup] group this obstacle belongs to
+        attr_reader :group
+
+        # @return [AIXM::Feature::Obstacle] another obstacle this one is linked to
+        attr_reader :linked_to
+
+        # @return [Symbol] type of link between two obstacles
+        attr_reader :link_type
+
+        def group=(value)
+          fail(ArgumentError, "invalid group") unless value.is_a?(AIXM::Feature::ObstacleGroup)
+          @group = value
+        end
+        private :group=
+
+        # @return [Boolean] whether obstacle is linked to another one
+        def linked?
+          !!linked_to
+        end
+
+        def linked_to=(value)
+          fail(ArgumentError, "invalid linked to") unless value.is_a?(AIXM::Feature::Obstacle)
+          @linked_to = value
+        end
+        private :linked_to=
+
+        def link_type=(value)
+          @link_type = AIXM::Feature::ObstacleGroup::LINK_TYPES.lookup(value&.to_s&.to_sym, nil) || fail(ArgumentError, "invalid link type")
+        end
+        private :link_type=
+      end
+
+    end
+  end
+end