voruby 1.1.1 → 2.0.0

data/lib/voruby/stc/1.10/region.rb

@@ -0,0 +1,892 @@
+require 'voruby/stc/support'
+require 'voruby/stc/1.10/coords'
+include VORuby::STC::V1_10::Coords
+
+module VORuby
+  module STC
+    module V1_10
+      module Region
+        include XMLUtilities
+        
+        # Region is the base type for everything.
+        class RegionType
+          include SerializableToXml
+          
+          attr_reader :note
+          
+          def initialize(options={})
+            options.each { |key, value| send("#{key}=", value) }
+          end
+          
+          # The fill_factor (value between 0 and 1) indicates the fraction of the region that
+          # is actually included; possible application: large scale resource coverage areas
+          def fill_factor
+            @fill_factor || 1.0
+          end
+          
+          def fill_factor=(f)
+            raise ArgumentError, "fill factor must be between 0.0 and 1.0" if f and (Float(f) < 0.0 or Float(f) > 1.0)
+            @fill_factor = f ? Float(f) : nil
+          end
+          
+          def note=(n)
+            @note = n ? n.to_s : nil
+          end
+          
+          def ==(r)
+            self.fill_factor == r.fill_factor and
+            self.note == r.note
+          end
+          
+          def to_xml(name=nil)
+            el = element(name)
+            
+            el.attributes["#{obj_ns.prefix}:fill_factor"] = self.fill_factor.to_s if self.fill_factor
+            el.attributes["#{obj_ns.prefix}:note"] = self.note if self.note
+            
+            collapse_namespaces(el)
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {}
+            
+            fill_factor = root.attributes.get_attribute_ns(obj_ns.uri, 'fill_factor')
+            options[:fill_factor] = Float(fill_factor.value) if fill_factor
+            
+            note = root.attributes.get_attribute_ns(obj_ns.uri, 'note')
+            options[:note] = note.value if note
+            
+            self.new(options)
+          end
+        end
+        
+        module Region; end
+        
+        # Shape is the abstract type that is the building block of regions; in real life it needs to be replaced by a concrete shape
+        class Shape < RegionType
+          include SerializableToXml
+          
+          attr_reader :coord_system_id, :unit
+          
+          def initialize(options={})
+            raise_argument_required_error('coord system id') if !options.has_key?(:coord_system_id)
+            options.each { |key, value| send("#{key}=", value) }
+          end
+          
+          def coord_system_id=(id)
+            raise_argument_required_error('coord sys id') if !id
+            @coord_system_id = id.is_a?(IdRef) ? id : IdRef.new(id.to_s)
+          end
+          
+          def unit=(u)
+            # unit should be required according to the schema, but I've seen
+            # examples (even in the official docs) where it's not.
+            if u
+              @unit = u.is_a?(PosUnit) ? u : PosUnit.new(u.to_s)
+            else
+              nil
+            end
+          end
+          
+          def ==(s)
+            self.coord_system_id == s.coord_system_id and
+            self.unit == s.unit
+          end
+          
+          def to_xml(name=nil)
+            el = super(name)
+            
+            el.attributes["#{obj_ns.prefix}:coord_system_id"] = self.coord_system_id.to_s
+            el.attributes["#{obj_ns.prefix}:unit"] = self.unit.to_s if self.unit
+            
+            collapse_namespaces(el)
+            
+            el
+          end
+        end
+        
+        # Circle shape: center and radius
+        class CircleType < Shape
+          attr_reader :center, :radius
+          
+          def self.xml_type; 'circleType' end
+          
+          def initialize(options={})
+            raise_argument_required_error('center') if !options.has_key?(:center)
+            raise_argument_required_error('radius') if !options.has_key?(:radius)
+            super(options)
+          end
+          
+          # The coordinates of the circle's center
+          def center=(c)
+            raise_argument_required_error('center') if !c
+            @center = Double2.new(c)
+          end
+          
+          # The radius of the circle
+          def radius=(r)
+            raise_argument_required_error('radius') if !r
+            @radius = Float(r)
+          end
+          
+          def ==(s)
+            super(s) and
+            self.center == s.center and
+            self.radius == s.radius
+          end
+          
+          def to_xml(name=nil)
+            el = super(name)
+            
+            el.add_element(self.center.to_xml("Center", obj_ns))
+            radius = REXML::Element.new("#{obj_ns.prefix}:Radius")
+            radius.text = self.radius.to_s
+            el.add_element(radius)
+            
+            collapse_namespaces(el)
+            el
+          end
+          
+          def to_s
+            "CIRCLE #{self.coord_system_id} #{self.center} #{self.radius}"
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            fill_factor = root.attributes.get_attribute_ns(obj_ns.uri, 'fill_factor')
+            note = root.attributes.get_attribute_ns(obj_ns.uri, 'note')
+            unit = root.attributes.get_attribute_ns(obj_ns.uri, 'unit')
+            options = {
+              :fill_factor => fill_factor ? Float(fill_factor.value) : nil,
+              :note => note ? note.value : nil,
+              :coord_system_id => IdRef.new(root.attributes.get_attribute_ns(obj_ns.uri, 'coord_system_id').value),
+              :unit => unit ? PosUnit.new(unit.value) : nil,
+              :center => Double2.from_xml(REXML::XPath.first(root, 'x:Center', {'x' => obj_ns.uri})),
+              :radius => Float(REXML::XPath.first(root, 'x:Radius', {'x' => obj_ns.uri}).text)
+            }
+            
+            self.new(options)
+          end
+        end
+        
+        class Circle < CircleType
+          include Region
+        end
+        
+        # AllSky is just a convenience, meaning no bounds
+        class AllSky < RegionType
+          include Region
+          
+          def to_xml(name=nil)
+            el = super(name)
+            el
+          end
+          
+          def to_s
+            "ALLSKY"
+          end
+        end
+        
+        # Ellipse shape: adds semi-minor axis and position angle to Circle
+        class EllipseType < CircleType
+          attr_reader :minor_radius, :pos_angle
+          
+          def self.xml_type; 'ellipseType' end
+          
+          def initialize(options={})
+            raise_argument_required_error('minor radius') if !options.has_key?(:minor_radius)
+            raise_argument_required_error('position angle') if !options.has_key?(:pos_angle)
+            super(options)
+          end
+          
+          # Half the minor axis of the ellipse, in radius_unit
+          def minor_radius=(r)
+            raise_argument_required_error('minor radius') if !r
+            @minor_radius = Float(r)
+          end
+          
+          # Position angle of major axis (Radius), counter-clockwise from north in pos_angle_unit
+          def pos_angle=(a)
+            raise_argument_required_error('position angle') if !a
+            @pos_angle = Float(a)
+          end
+          
+          def pos_angle_unit=(u)
+            raise ArgumentError, 'position angle unit required' if !u
+            @pos_angle_unit = u.is_a?(AngleUnit) ? u : AngleUnit.new(u.to_s)
+          end
+          
+          def pos_angle_unit
+            @pos_angle_unit || AngleUnit.new('deg')
+          end
+          
+          def ==(s)
+            super(s) and
+            self.minor_radius = s.minor_radius and
+            self.pos_angle = s.pos_angle and
+            self.pos_angle_unit = s.pos_angle_unit
+          end
+          
+          def to_xml(name=nil)
+            el = super(name)
+            
+            el.attributes["#{obj_ns.prefix}:pos_angle_unit"] = self.pos_angle_unit.to_s
+            
+            minor_radius = REXML::Element.new("#{obj_ns.prefix}:MinorRadius")
+            minor_radius.text = self.minor_radius.to_s
+            el.add_element(minor_radius)
+            
+            pos_angle = REXML::Element.new("#{obj_ns.prefix}:PosAngle")
+            pos_angle.text = self.pos_angle.to_s
+            el.add_element(pos_angle)
+            
+            collapse_namespaces(el)
+          
+            el
+          end
+          
+          def to_s
+            "ELLIPSE #{self.coord_system_id} #{self.center} #{self.radius} #{self.minor_radius} #{self.pos_angle}"
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            fill_factor = root.attributes.get_attribute_ns(obj_ns.uri, 'fill_factor')
+            note = root.attributes.get_attribute_ns(obj_ns.uri, 'note')
+            unit = root.attributes.get_attribute_ns(obj_ns.uri, 'unit')
+            options = {
+              :fill_factor => fill_factor ? Float(fill_factor.value) : nil,
+              :note => note ? note.value : nil,
+              :coord_system_id => IdRef.new(root.attributes.get_attribute_ns(obj_ns.uri, 'coord_system_id').value),
+              :pos_angle_unit => AngleUnit.new(root.attributes.get_attribute_ns(obj_ns.uri, 'pos_angle_unit').value),
+              :unit => unit ? PosUnit.new(unit.value) : nil,
+              :center => Double2.from_xml(REXML::XPath.first(root, 'x:Center', {'x' => obj_ns.uri})),
+              :radius => Float(REXML::XPath.first(root, 'x:Radius', {'x' => obj_ns.uri}).text),
+              :minor_radius => Float(REXML::XPath.first(root, 'x:MinorRadius', {'x' => obj_ns.uri}).text),
+              :pos_angle => Float(REXML::XPath.first(root, 'x:PosAngle', {'x' => obj_ns.uri}).text)
+            }
+            
+            self.new(options)
+          end
+        end
+        
+        class Ellipse < EllipseType
+          include Region
+        end
+        
+        # SmallCircle is used in vertices to indicate that the polygon side associated with the vertex
+        # is to be a small circle rather than the default great circle.
+        # SmallCircle indicates in polygons that side is along small circle; with optional pole.
+        class SmallCircle
+          include SerializableToXml
+          
+          attr_reader :pole
+          
+          def initialize(options={})
+            options.is_a?(Hash) ? options.each { |key, value| send("#{key}=", value) } : self.pole = options
+          end
+          
+          def pole=(p)
+            p = Double2.new(p) if p and p.class == Array
+            raise_type_mismatch_error(p, Double2) if p
+            @pole = p
+          end
+          
+          def ==(c)
+            self.pole == c.pole
+          end
+          
+          def to_xml(name=nil)
+            el = element(name)
+            
+            el.add_element(self.pole.to_xml('Pole', obj_ns)) if pole
+            
+            collapse_namespaces(el)
+            
+            el
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {}
+            pole = REXML::XPath.first(root, 'x:Pole', {'x' => obj_ns.uri})
+            options[:pole] = Double2.from_xml(pole) if pole
+            
+            SmallCircle.new(options)
+          end
+        end
+        
+        # Vertex is a position with optional SmallCircle element
+        class Vertex
+          include SerializableToXml
+          
+          attr_reader :position, :small_circle
+          
+          def initialize(options={})
+            raise_argument_required_error('position') if !options.has_key?(:position)
+            options.each { |key, value| send("#{key}=", value) }
+          end
+          
+          def position=(p)
+            raise_argument_required_error('position') if !p
+            p = Double2.new(p) if p.class == Array
+            raise_type_mismatch_error(p, Double2) 
+            @position = p
+          end
+          
+          def small_circle=(c)
+            raise_type_mismatch_error(c, SmallCircle) if c
+            @small_circle = c
+          end
+          
+          def ==(v)
+            self.position == v.position and
+            self.small_circle == v.small_circle
+          end
+          
+          def to_xml(name=nil)
+            el = element(name)
+            
+            el.add_element(self.position.to_xml('Position', obj_ns))
+            el.add_element(self.small_circle.to_xml('SmallCircle')) if self.small_circle
+            
+            collapse_namespaces(el)
+            
+            el
+          end
+          
+          def to_s
+            self.position.to_s
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :position => Double2.from_xml(REXML::XPath.first(root, 'x:Position', {'x' => obj_ns.uri}))
+            }
+            
+            small_circle = REXML::XPath.first(root, 'x:SmallCircle', {'x' => obj_ns.uri})
+            options[:small_circle] = SmallCircle.from_xml(small_circle) if small_circle
+            
+            Vertex.new(options) 
+          end
+        end
+        
+        class VertexList < TypedArray
+          def self.restricted_to; [Vertex] end
+          def self.minimum_length; 1 end
+        end
+        
+        # Polygon: one or more vertices; counter-clockwise encircled area is enclosed;
+        # cyclical coordinates may exceed 0 and 360 limits if necessary
+        class PolygonType < Shape
+          attr_reader :vertices
+          
+          def self.xml_type; 'polygonType' end
+          
+          def initialize(options={})
+            raise_argument_required_error('list of vertexes') if !options.has_key?(:vertices)
+            super(options)
+          end  
+          
+          # In order to form polygons, vertices are to be connected with straight line segments.
+          # In the case of spherical coordinates: GreatCircle segments; if a SmallCircle element
+          # is present, the vertex and its predecessor are to be connected with a SmallCircle, by
+          # default in the CoordSys that is referenced; optionally, a pole may be specified (other
+          # than the CoordSys pole) that defines the SmallCircle system
+          def vertices=(vs)
+            raise_argument_required_error('list of vertexes') if !vs
+            
+            vs = VertexList.new(vs) if vs.class == Array
+            raise_type_mismatch_error(vs, VertexList)
+            
+            @vertices = vs
+          end
+          
+          def ==(p)
+            super(p) and
+            self.vertices == p.vertices
+          end
+          
+          def to_xml(name=nil)
+            el = super(name)
+            self.vertices.each { |v| el.add_element(v.to_xml('Vertex')) }
+            collapse_namespaces(el)
+            el
+          end
+          
+          def to_s
+            "POLYGON #{self.coord_system_id} #{self.vertices.collect{ |v| v.to_s }.join(' ')}"
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            fill_factor = root.attributes.get_attribute_ns(obj_ns.uri, 'fill_factor')
+            note = root.attributes.get_attribute_ns(obj_ns.uri, 'note')
+            unit = root.attributes.get_attribute_ns(obj_ns.uri, 'unit')
+            options = {
+              :fill_factor => fill_factor ? Float(fill_factor.value) : nil,
+              :note => note ? note.value : nil,
+              :coord_system_id => IdRef.new(root.attributes.get_attribute_ns(obj_ns.uri, 'coord_system_id').value),
+              :unit => unit ? PosUnit.new(unit.value) : nil,
+              :vertices => VertexList.new(xml_to_obj(root, Vertex))
+            }
+            
+            self.new(options)
+          end
+        end
+        
+        class Polygon < PolygonType
+          include Region
+        end
+        
+        # A sector is the counter-clockwise area between two half-lines
+        class SectorType < Shape
+          attr_reader :position, :pos_angle1, :pos_angle2
+          
+          def self.xml_type; 'sectorType' end
+          
+          def initialize(options)
+            raise_argument_required_error('position') if !options.has_key?(:position)
+            raise_argument_required_error('position angle 1') if !options.has_key?(:pos_angle1)
+            raise_argument_required_error('position angle 2') if !options.has_key?(:pos_angle2)
+            super(options)
+          end
+          
+          # The vertex position of the sector
+          def position=(p)
+            raise_argument_required_error('position') if !p
+            p = Double2.new(p) if p.class == Array
+            raise_type_mismatch_error(p, Double2)
+            @position = p
+          end
+          
+          # The area ccw from this position angle is included
+          def pos_angle1=(a)
+            raise_argument_required_error('position angle 1') if !a
+            @pos_angle1 = Float(a)
+          end
+          
+          # The area cw from this position angle is included
+          def pos_angle2=(a)
+            raise_argument_required_error('position angle 2') if !a
+            @pos_angle2 = Float(a)
+          end
+          
+          def pos_angle_unit=(u)
+            raise_argument_required_error('position angle unit') if !u
+            @pos_angle_unit = u.is_a?(PosUnit) ? u : PosUnit.new(u.to_s)
+          end
+          
+          def pos_angle_unit
+            @pos_angle_unit || PosUnit.new('deg')
+          end
+          
+          def ==(s)
+            super(s) and
+            self.position == s.position and
+            self.pos_angle1 == s.pos_angle1 and
+            self.pos_angle2 == s.pos_angle2 and
+            self.pos_angle_unit == s.pos_angle_unit
+          end
+          
+          def to_xml(name=nil)
+            el = super(name)
+            
+            el.attributes["#{obj_ns.prefix}:pos_angle_unit"] = self.pos_angle_unit.to_s
+            
+            el.add_element(self.position.to_xml('Position', obj_ns))
+            
+            pos_angle1 = REXML::Element.new("#{obj_ns.prefix}:PosAngle1")
+            pos_angle1.text = self.pos_angle1.to_s
+            el.add_element(pos_angle1)
+            
+            pos_angle2 = REXML::Element.new("#{obj_ns.prefix}:PosAngle2")
+            pos_angle2.text = self.pos_angle2.to_s
+            el.add_element(pos_angle2)
+            
+            collapse_namespaces(el)
+            
+            el
+          end
+          
+          def to_s
+            "SECTOR #{self.coord_system_id} #{self.position} #{self.pos_angle1} #{self.pos_angle2}"
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            fill_factor = root.attributes.get_attribute_ns(obj_ns.uri, 'fill_factor')
+            note = root.attributes.get_attribute_ns(obj_ns.uri, 'note')
+            options = {
+              :fill_factor => fill_factor ? Float(fill_factor.value) : nil,
+              :note => note ? note.value : nil,
+              :coord_system_id => IdRef.new(root.attributes.get_attribute_ns(obj_ns.uri, 'coord_system_id').value),
+              :position => Double2.from_xml(REXML::XPath.first(root, 'x:Position', {'x' => obj_ns.uri})),
+              :pos_angle1 => Float(REXML::XPath.first(root, 'x:PosAngle1', {'x' => obj_ns.uri}).text),
+              :pos_angle2 => Float(REXML::XPath.first(root, 'x:PosAngle2', {'x' => obj_ns.uri}).text)
+            }
+            
+            unit = root.attributes.get_attribute_ns(obj_ns.uri, 'unit')
+            options[:unit] = PosUnit.new(unit.value) if unit
+            
+            pos_angle_unit = root.attributes.get_attribute_ns(obj_ns.uri, 'pos_angle_unit')
+            options[:pos_angle_unit] = PosUnit.new(pos_angle_unit.value) if pos_angle_unit
+            
+            self.new(options)
+          end
+        end
+        
+        class Sector < SectorType
+          include Region
+        end
+        
+        # An area on the unit sphere defined by the intersection with a plane
+        class Constraint
+          include SerializableToXml
+          
+          attr_reader :vector, :offset
+          
+          def initialize(options={})
+            raise_argument_required_error('vector') if !options.has_key?(:vector)
+            raise_argument_required_error('offset') if !options.has_key?(:offset)
+            options.each { |key, value| send("#{key}=", value) }
+          end
+          
+          # This needs to be a spherical coordinate vector; it is the unit vector that
+          # is normal to the plane that forms a constraint for a convex
+          def vector=(v)
+            raise_argument_required_error('vector') if !v
+            v = Double3.new(v) if v.class == Array
+            
+            raise_type_mismatch_error(v, Double3)
+            @vector = v
+          end
+          
+          # The distance along the normal vector where the constraint plane intersects
+          # that vector; if positive, the spherical sector on the far side (seen from
+          # the center) is selected; if negative, the point of intersection is in the
+          # opposite direction of the vector, resulting in more than a hemisphere
+          def offset=(o)
+            raise_argument_required_error('offset') if !o
+            @offset = Float(o)
+          end
+          
+          def ==(c)
+            self.vector == c.vector and
+            self.offset == c.offset
+          end
+          
+          def to_xml(name=nil)
+            el = element(name)
+            
+            el.add_element(self.vector.to_xml('Vector', obj_ns))
+            
+            offset = REXML::Element.new("#{obj_ns.prefix}:Offset")
+            offset.text = self.offset.to_s
+            el.add_element(offset)
+            
+            collapse_namespaces(el)
+            
+            el
+          end
+          
+          def to_s
+            "#{self.vector} #{self.offset}"
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :vector => Double3.from_xml(REXML::XPath.first(root, 'x:Vector', {'x' => obj_ns.uri})),
+              :offset => Float(REXML::XPath.first(root, 'x:Offset', {'x' => obj_ns.uri}).text)
+            }
+            
+            Constraint.new(options)
+          end
+        end
+        
+        class ConstraintList < TypedArray
+          def self.restricted_to; [Constraint] end
+          def self.minimum_length; 1 end
+        end
+        
+        # A convex polygon defined by one or more Constraints
+        class ConvexType < Shape
+          attr_reader :constraints
+          
+          def self.xml_type; 'convexType' end
+          
+          def initialize(options={})
+            raise_argument_required_error('list of constraints') if !options.has_key?(:constraints)
+            super(options)
+          end
+          
+          def constraints=(cs)
+            raise_argument_required_error('list of constraints') if !cs
+            
+            cs = ConstraintList.new(cs) if cs.class == Array
+            raise_type_mismatch_error(cs, ConstraintList)
+            
+            @constraints = cs
+          end
+          
+          def ==(c)
+            super(c) and
+            self.constraints == c.constraints
+          end
+          
+          def to_xml(name=nil)
+            el = super(name)
+            self.constraints.each { |c| el.add_element(c.to_xml('Constraint')) }
+            collapse_namespaces(el)
+            el
+          end
+          
+          def to_s
+            "CONVEX #{self.coord_system_id} #{self.constraints.collect{ |c| c.to_s }.join(' ') }"
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            fill_factor = root.attributes.get_attribute_ns(obj_ns.uri, 'fill_factor')
+            note = root.attributes.get_attribute_ns(obj_ns.uri, 'note')
+            options = {
+              :fill_factor => fill_factor ? Float(fill_factor.value) : nil,
+              :note => note ? note.value : nil,
+              :coord_system_id => IdRef.new(root.attributes.get_attribute_ns(obj_ns.uri, 'coord_system_id').value),
+              :constraints => REXML::XPath.match(root, 'x:Constraint', {'x' => obj_ns.uri}).collect{ |c| Constraint.from_xml(c) }
+            }
+            unit = root.attributes.get_attribute_ns(obj_ns.uri, 'unit')
+            options[:unit] = PosUnit.new(unit.value) if unit
+            
+            self.new(options)
+          end
+        end
+        
+        class Convex < ConvexType
+          include Region
+        end
+        
+        class PointList < TypedArray
+          def self.restricted_to; [Double3] end
+          def self.minimum_length; 1 end
+        end
+        
+        # A convex hull
+        class ConvexHullType < Shape
+          attr_reader :points
+          
+          def self.xml_type; 'convexHullType' end
+          
+          def initialize(options={})
+            raise_argument_required_error('list of points') if !options.has_key?(:points)
+            super(options)
+          end
+          
+          def points=(ps)
+            raise_argument_required_error('list of points') if !ps
+            
+            ps = PointList.new(ps) if ps.class == Array
+            raise_type_mismatch_error(ps, PointList)
+            
+            @points = ps
+          end
+          
+          def ==(c)
+            super(c) and
+            self.points == c.points
+          end
+          
+          def to_xml(name=nil)
+            el = super(name)
+            self.points.each { |p| el.add_element(p.to_xml('Point', obj_ns)) }
+            collapse_namespaces(el)
+            el
+          end
+          
+          def to_s
+            "CHULL #{self.coord_system_id} #{self.points}"
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            fill_factor = root.attributes.get_attribute_ns(obj_ns.uri, 'fill_factor')
+            note = root.attributes.get_attribute_ns(obj_ns.uri, 'note')
+            options = {
+              :fill_factor => fill_factor ? Float(fill_factor.value) : nil,
+              :note => note ? note.value : nil,
+              :coord_system_id => IdRef.new(root.attributes.get_attribute_ns(obj_ns.uri, 'coord_system_id').value),
+              :points => PointList.new(
+                REXML::XPath.match(root, 'x:Point', {'x' => obj_ns.uri}).collect{ |p| Double3.from_xml(p) }
+              )
+            }
+            unit = root.attributes.get_attribute_ns(obj_ns.uri, 'unit')
+            options[:unit] = PosUnit.new(unit.value) if unit
+            
+            self.new(options)
+          end
+        end
+        
+        class ConvexHull < ConvexHullType
+          include Region
+        end
+        
+        # This is a generic hook for regions defined in sky indexing schemes
+        class SkyIndexType < Shape
+          def self.xml_type; 'skyIndexType' end
+        end
+        
+        class SkyIndex < SkyIndexType
+          include Region
+        end
+        
+        class RegionList < TypedArray
+          def self.restricted_to; [Region] end
+          def self.minimum_length; 2 end
+        end
+        
+        class BooleanOperatorType < RegionType
+          include SerializableToXml
+          
+          attr_reader :regions
+          
+          def initialize(options={})
+            raise_argument_required_error('list of regions') if !options.has_key?(:regions)
+            super(options)
+          end
+          
+          def regions=(rs)
+            raise_argument_required_error('list of regions') if !rs
+            
+            rs = RegionList.new(rs) if rs.class == Array
+            raise_type_mismatch_error(rs, RegionList)
+            
+            @regions = rs
+          end
+          
+          def ==(u)
+            super(u) and
+            self.regions == u.regions
+          end
+          
+          def to_xml(name=nil)
+            el = super(name)
+            self.regions.each { |r| el.add_element(r.to_xml) }
+            collapse_namespaces(el)
+            el
+          end
+          
+          def to_s(name)
+            "#{name}(#{self.regions.collect{ |r| r.to_s }.join(' ')})"
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+            
+            options = {
+              :regions => xml_to_obj(root, Region)
+            }
+            fill_factor = root.attributes.get_attribute_ns(obj_ns.uri, 'fill_factor')
+            options[:fill_factor] = Float(fill_factor.value) if fill_factor
+            note = root.attributes.get_attribute_ns(obj_ns.uri, 'note')
+            options[:note] = note.value if note
+            
+            self.new(options)
+          end
+        end
+        
+        # The union of two or more regions is a region
+        class UnionType < BooleanOperatorType
+          def self.xml_type; 'unionType' end
+          
+          def to_s
+            super('UNION')
+          end
+        end
+        
+        class Union < UnionType
+          include Region
+        end
+        
+        # The intersection of two or more regions is a region
+        class IntersectionType < BooleanOperatorType
+          def self.xml_type; 'intersectionType' end
+          
+          def to_s
+            super('INTERSECT')
+          end
+        end
+        
+        class Intersection < IntersectionType
+          include Region
+        end
+        
+        class NegationType < RegionType
+          attr_reader :region
+          
+          def self.xml_type; 'negationType' end
+          
+          def initialize(options={})
+            raise_argument_required_error('region') if !options.has_key?(:region)
+            super(options)
+          end
+          
+          def region=(r)
+            raise_argument_required_error('region') if !r
+            raise TypeError, "invalid value #{r}, expected Region" if !r.is_a?(Region)
+            
+            @region = r
+          end
+          
+          def ==(n)
+            super(n) and
+            self.region == n.region
+          end
+          
+          def to_xml(name=nil)
+            el = element(name)
+            el.add_element(self.region.to_xml)
+            collapse_namespaces(name)
+            el
+          end
+          
+          def to_s
+            "NOT(#{self.region})"
+          end
+          
+          def self.from_xml(xml)
+            root = element_from(xml)
+          
+            options = {
+              :region => xml_to_obj(root, Region, true)
+            }
+            fill_factor = root.attributes.get_attribute_ns(obj_ns.uri, 'fill_factor')
+            options[:fill_factor] = Float(fill_factor.value) if fill_factor
+            note = root.attributes.get_attribute_ns(obj_ns.uri, 'note')
+            options[:note] = note.value if note
+            
+            self.new(options)
+          end
+        end
+        
+        class Negation < NegationType
+          include Region
+        end
+        
+      end
+    end
+  end
+end