Module: RGeo::Feature::Geometry
 Extended by:
 Type
 Included in:
 Curve, GeometryCollection, Point, Surface, Geos::CAPIGeometryImpl, Geos::FFIGeometryImpl
 Defined in:
 lib/rgeo/feature/geometry.rb
Overview
SFS 1.1 Description
Geometry is the root class of the hierarchy. Geometry is an abstract (noninstantiable) class.
The instantiable subclasses of Geometry defined in this International Standard are restricted to 0, 1 and 2dimensional geometric objects that exist in 2dimensional coordinate space (R2).
All instantiable Geometry classes described in this part of ISO 19125 are defined so that valid instances of a Geometry class are topologically closed, i.e. all defined geometries include their boundary.
Notes
Geometry is defined as a module and is provided primarily for the sake of documentation. Implementations need not necessarily include this module itself. Therefore, you should not depend on the result of is_a?(Geometry)
to check type. Instead, use the provided check_type class method (or === operator) defined in the Type module.
Some implementations may support higher dimensional objects or coordinate systems, despite the limits of the SFS.
Forms of equivalence
The Geometry model defines three forms of equivalence.

Spatial equivalence is the weakest form of equivalence, indicating that the objects represent the same region of space, but may be different representations of that region. For example, POINT(0 0) and a MULTIPOINT(0 0) are spatially equivalent, as are LINESTRING(0 0, 10 10) and GEOMETRYCOLLECTION(POINT(0 0), LINESTRING(0 0, 10 10, 0 0)). As a general rule, objects must have factories that are Factory#eql? in order to be spatially equivalent.

Representational equivalence is a stronger form, indicating that the objects have the same representation, but may be different objects. All representationally equivalent objects are spatially equivalent, but not all spatially equivalent objects are representationally equivalent. For example, none of the examples in the spatial equivalence section above are representationally equivalent. However, two separate objects that both represent POINT(1 2) are representationally equivalent as well as spatially equivalent.

Objective equivalence is the strongest form, indicating that the references refer to the same object. Of course, all pairs of references with the same objective identity are also both representationally and spatially equivalent.
Different methods test for different types of equivalence:

equals?
and==
test for spatial equivalence. 
rep_equals?
andeql?
test for representational equivalence. 
equal?
tests for objective equivalence.
All ruby objects must provide a suitable test for objective equivalence. Normally, this is simply provided by the Ruby Object base class. Geometry implementations should normally also provide tests for representational and spatial equivalence, if possible. The ==
operator and the eql?
method are standard Ruby methods that are often expected to be usable for every object. Therefore, if an implementation cannot provide a suitable test for their equivalence types, they must degrade to use a stronger form of equivalence.
Instance Method Summary collapse

#*(rhs) ⇒ Object
If the given rhs is a geometry object, this operator must behave the same as the intersection method.

#+(rhs) ⇒ Object
If the given rhs is a geometry object, this operator must behave the same as the union method.

#(rhs) ⇒ Object
If the given rhs is a geometry object, this operator must behave the same as the difference method.

#==(rhs) ⇒ Object
This operator should behave almost the same as the equals? method, with two key differences.

#as_binary ⇒ Object
SFS 1.1 Description.

#as_text ⇒ Object
SFS 1.1 Description.

#boundary ⇒ Object
SFS 1.1 Description.

#buffer(_distance_) ⇒ Object
SFS 1.1 Description.

#contains?(another_geometry) ⇒ Boolean
SFS 1.1 Description.

#convex_hull ⇒ Object
SFS 1.1 Description.

#coordinate_dimension ⇒ Integer
SFS 1.2 Description.

#crosses?(another_geometry) ⇒ Boolean
SFS 1.1 Description.

#difference(another_geometry) ⇒ Object
SFS 1.1 Description.

#dimension ⇒ Object
SFS 1.1 Description.

#disjoint?(another_geometry) ⇒ Boolean
SFS 1.1 Description.

#distance(another_geometry) ⇒ Object
SFS 1.1 Description.

#empty? ⇒ Boolean
SFS 1.1 Description.

#envelope ⇒ Object
SFS 1.1 Description.

#eql?(rhs) ⇒ Boolean
This method should behave almost the same as the rep_equals? method, with two key differences.

#equals?(another_geometry) ⇒ Boolean
SFS 1.1 Description.

#factory ⇒ Object
Returns a factory for creating features related to this one.

#geometry_type ⇒ Object
SFS 1.1 Description.

#intersection(another_geometry) ⇒ Object
SFS 1.1 Description.

#intersects?(another_geometry) ⇒ Boolean
SFS 1.1 Description.

#is_3d? ⇒ Boolean
SFS 1.2 Description.
 #is_empty? ⇒ Boolean
 #is_simple? ⇒ Boolean

#locate_along ⇒ RGeo::Feature::GeometryCollection
SFS 1.2 Description.

#locate_between ⇒ RGeo::Feature::GeometryCollection
SFS 1.2 Description.

#measured? ⇒ Boolean
SFS 1.2 Description.

#overlaps?(another_geometry) ⇒ Boolean
SFS 1.1 Description.

#relate?(another_geometry, _intersection_pattern_matrix_) ⇒ Boolean
SFS 1.1 Description.

#rep_equals?(another_geometry) ⇒ Boolean
Returns true if this geometric object is representationally equivalent to the given object.

#simple? ⇒ Boolean
SFS 1.1 Description.

#spatial_dimension ⇒ Integer
SFS 1.2 Description.

#srid ⇒ Object
SFS 1.1 Description.

#sym_difference(another_geometry) ⇒ Object
SFS 1.1 Description.

#touches?(another_geometry) ⇒ Boolean
SFS 1.1 Description.

#unary_union ⇒ Object
Unions a collection of Geometry or a single Geometry (which may be a collection) together.

#union(another_geometry) ⇒ Object
SFS 1.1 Description.

#within?(another_geometry) ⇒ Boolean
SFS 1.1 Description.
Methods included from Type
add_subtype, check_type, each_immediate_subtype, extended, subtype_of?, supertype, type_name
Instance Method Details
#*(rhs) ⇒ Object
If the given rhs is a geometry object, this operator must behave the same as the intersection method. The behavior for other rhs types is not specified; an implementation may choose to provide additional capabilities as appropriate.
721 722 723 
# File 'lib/rgeo/feature/geometry.rb', line 721 def *(rhs) intersection(rhs) end 
#+(rhs) ⇒ Object
If the given rhs is a geometry object, this operator must behave the same as the union method. The behavior for other rhs types is not specified; an implementation may choose to provide additional capabilities as appropriate.
712 713 714 
# File 'lib/rgeo/feature/geometry.rb', line 712 def +(rhs) union(rhs) end 
#(rhs) ⇒ Object
If the given rhs is a geometry object, this operator must behave the same as the difference method. The behavior for other rhs types is not specified; an implementation may choose to provide additional capabilities as appropriate.
703 704 705 
# File 'lib/rgeo/feature/geometry.rb', line 703 def (rhs) difference(rhs) end 
#==(rhs) ⇒ Object
This operator should behave almost the same as the equals? method, with two key differences.
First, the == operator is required to handle rhs values that are not geometry objects (returning false in such cases) in order to fulfill the standard Ruby contract for the == operator, whereas the equals? method may assume that any rhs is a geometry.
Second, the == operator should always be defined. That is, it should never raise Error::UnsupportedOperation. In cases where the underlying implementation cannot provide a spatial equivalence test, the == operator must fall back on representational or objective equivalence.
686 687 688 689 690 691 692 693 694 695 696 
# File 'lib/rgeo/feature/geometry.rb', line 686 def ==(rhs) if rhs.is_a?(RGeo::Feature::Instance) begin equals?(rhs) rescue Error::UnsupportedOperation eql?(rhs) end else false end end 
#as_binary ⇒ Object
SFS 1.1 Description
Exports this geometric object to a specific Wellknown Binary Representation of Geometry.
Notes
Returns a binary string.
209 210 211 
# File 'lib/rgeo/feature/geometry.rb', line 209 def as_binary raise Error::UnsupportedOperation, "Method #{self.class}#as_binary not defined." end 
#as_text ⇒ Object
SFS 1.1 Description
Exports this geometric object to a specific Wellknown Text Representation of Geometry.
Notes
Returns an ASCII string.
196 197 198 
# File 'lib/rgeo/feature/geometry.rb', line 196 def as_text raise Error::UnsupportedOperation, "Method #{self.class}#as_text not defined." end 
#boundary ⇒ Object
SFS 1.1 Description
Returns the closure of the combinatorial boundary of this geometric object. Because the result of this function is a closure, and hence topologically closed, the resulting boundary can be represented using representational Geometry primitives.
Notes
Returns an object that supports the Geometry interface.
288 289 290 
# File 'lib/rgeo/feature/geometry.rb', line 288 def boundary raise Error::UnsupportedOperation, "Method #{self.class}#boundary not defined." end 
#buffer(_distance_) ⇒ Object
SFS 1.1 Description
Returns a geometric object that represents all Points whose distance from this geometric object is less than or equal to distance. Calculations are in the spatial reference system of this geometric object.
Notes
Returns an object that supports the Geometry interface.
527 528 529 
# File 'lib/rgeo/feature/geometry.rb', line 527 def buffer(_distance_) raise Error::UnsupportedOperation, "Method #{self.class}#buffer not defined." end 
#contains?(another_geometry) ⇒ Boolean
SFS 1.1 Description
Returns true if this geometric object “spatially contains” another_geometry.
Notes
Returns a boolean value. Note that this is different from the SFS specification, which stipulates an integer return value.
Although implementations are free to attempt to handle another_geometry values that do not share the same factory as this geometry, strictly speaking, the result of comparing objects from different factories is undefined.
421 422 423 
# File 'lib/rgeo/feature/geometry.rb', line 421 def contains?(another_geometry) raise Error::UnsupportedOperation, "Method #{self.class}#contains? not defined." end 
#convex_hull ⇒ Object
SFS 1.1 Description
Returns a geometric object that represents the convex hull of this geometric object.
Notes
Returns an object that supports the Geometry interface.
540 541 542 
# File 'lib/rgeo/feature/geometry.rb', line 540 def convex_hull raise Error::UnsupportedOperation, "Method #{self.class}#convex_hull not defined." end 
#coordinate_dimension ⇒ Integer
SFS 1.2 Description
The coordinate dimension is the dimension of direct positions (coordinate tuples) used in the definition of this geometric object
Notes
Difference between this and dimension is that this is the dimension of the coordinate not the dimension of the geometry.
122 123 124 
# File 'lib/rgeo/feature/geometry.rb', line 122 def coordinate_dimension raise Error::UnsupportedOperation, "Method #{self.class}#coordinate_dimension not defined." end 
#crosses?(another_geometry) ⇒ Boolean
SFS 1.1 Description
Returns true if this geometric object “spatially crosses” another_geometry.
Notes
Returns a boolean value. Note that this is different from the SFS specification, which stipulates an integer return value.
Although implementations are free to attempt to handle another_geometry values that do not share the same factory as this geometry, strictly speaking, the result of comparing objects from different factories is undefined.
383 384 385 
# File 'lib/rgeo/feature/geometry.rb', line 383 def crosses?(another_geometry) raise Error::UnsupportedOperation, "Method #{self.class}#crosses? not defined." end 
#difference(another_geometry) ⇒ Object
SFS 1.1 Description
Returns a geometric object that represents the Point set difference of this geometric object with another_geometry.
Notes
Returns an object that supports the Geometry interface.
Although implementations are free to attempt to handle another_geometry values that do not share the same factory as this geometry, strictly speaking, the result of performing operations on objects from different factories is undefined.
594 595 596 
# File 'lib/rgeo/feature/geometry.rb', line 594 def difference(another_geometry) raise Error::UnsupportedOperation, "Method #{self.class}#difference not defined." end 
#dimension ⇒ Object
SFS 1.1 Description
The inherent dimension of this geometric object, which must be less than or equal to the coordinate dimension. This specification is restricted to geometries in 2dimensional coordinate space.
Notes
Returns an integer. This value is 1 for an empty geometry, 0 for point geometries, 1 for curves, and 2 for surfaces.
107 108 109 
# File 'lib/rgeo/feature/geometry.rb', line 107 def dimension raise Error::UnsupportedOperation, "Method #{self.class}#dimension not defined." end 
#disjoint?(another_geometry) ⇒ Boolean
SFS 1.1 Description
Returns true if this geometric object is “spatially disjoint” from another_geometry.
Notes
Returns a boolean value. Note that this is different from the SFS specification, which stipulates an integer return value.
Although implementations are free to attempt to handle another_geometry values that do not share the same factory as this geometry, strictly speaking, the result of comparing objects from different factories is undefined.
326 327 328 
# File 'lib/rgeo/feature/geometry.rb', line 326 def disjoint?(another_geometry) raise Error::UnsupportedOperation, "Method #{self.class}#disjoint? not defined." end 
#distance(another_geometry) ⇒ Object
SFS 1.1 Description
Returns the shortest distance between any two Points in the two geometric objects as calculated in the spatial reference system of this geometric object.
Notes
Returns a floatingpoint scalar value.
Although implementations are free to attempt to handle another_geometry values that do not share the same factory as this geometry, strictly speaking, the result of measuring the distance between objects from different factories is undefined.
512 513 514 
# File 'lib/rgeo/feature/geometry.rb', line 512 def distance(another_geometry) raise Error::UnsupportedOperation, "Method #{self.class}#distance not defined." end 
#empty? ⇒ Boolean
SFS 1.1 Description
Returns true if this geometric object is the empty Geometry. If true, then this geometric object represents the empty point set for the coordinate space.
Notes
Returns a boolean value. Note that this is different from the SFS specification, which stipulates an integer return value.
224 225 226 
# File 'lib/rgeo/feature/geometry.rb', line 224 def empty? raise Error::UnsupportedOperation, "Method #{self.class}#empty? not defined." end 
#envelope ⇒ Object
SFS 1.1 Description
The minimum bounding box for this Geometry, returned as a Geometry. The polygon is defined by the corner points of the bounding box [(MINX, MINY), (MAXX, MINY), (MAXX, MAXY), (MINX, MAXY), (MINX, MINY)].
Notes
Returns an object that supports the Geometry interface.
183 184 185 
# File 'lib/rgeo/feature/geometry.rb', line 183 def envelope raise Error::UnsupportedOperation, "Method #{self.class}#envelope not defined." end 
#eql?(rhs) ⇒ Boolean
This method should behave almost the same as the rep_equals? method, with two key differences.
First, the eql?
method is required to handle rhs values that are not geometry objects (returning false in such cases) in order to fulfill the standard Ruby contract for the method, whereas the rep_equals? method may assume that any rhs is a geometry.
Second, the eql?
method should always be defined. That is, it should never raise Error::UnsupportedOperation. In cases where the underlying implementation cannot provide a representational equivalence test, this method must fall back on objective equivalence.
660 661 662 663 664 665 666 667 668 669 670 
# File 'lib/rgeo/feature/geometry.rb', line 660 def eql?(rhs) if rhs.is_a?(RGeo::Feature::Instance) begin rep_equals?(rhs) rescue Error::UnsupportedOperation equal?(rhs) end else false end end 
#equals?(another_geometry) ⇒ Boolean
SFS 1.1 Description
Returns true if this geometric object is “spatially equal” to another_geometry.
Notes
Returns a boolean value. Note that this is different from the SFS specification, which stipulates an integer return value.
Although implementations are free to attempt to handle another_geometry values that do not share the same factory as this geometry, strictly speaking, the result of comparing objects from different factories is undefined.
307 308 309 
# File 'lib/rgeo/feature/geometry.rb', line 307 def equals?(another_geometry) raise Error::UnsupportedOperation, "Method #{self.class}#equals? not defined." end 
#factory ⇒ Object
Returns a factory for creating features related to this one. This does not necessarily need to be the same factory that created this object, but it should create objects that are “compatible” with this one. (i.e. they should be in the same spatial reference system by default, and it should be possible to perform relational operations on them.)
92 93 94 
# File 'lib/rgeo/feature/geometry.rb', line 92 def factory raise Error::UnsupportedOperation, "Method #{self.class}#factory not defined." end 
#geometry_type ⇒ Object
SFS 1.1 Description
Returns the instantiable subtype of Geometry of which this geometric object is an instantiable member.
Notes
Returns one of the type modules in RGeo::Feature. e.g. a point object would return RGeo::Feature::Point. Note that this is different from the SFS specification, which stipulates that the string name of the type is returned. To obtain the name string, call the type_name
method of the returned module.
154 155 156 
# File 'lib/rgeo/feature/geometry.rb', line 154 def geometry_type raise Error::UnsupportedOperation, "Method #{self.class}#geometry_type not defined." end 
#intersection(another_geometry) ⇒ Object
SFS 1.1 Description
Returns a geometric object that represents the Point set intersection of this geometric object with another_geometry.
Notes
Returns an object that supports the Geometry interface.
Although implementations are free to attempt to handle another_geometry values that do not share the same factory as this geometry, strictly speaking, the result of performing operations on objects from different factories is undefined.
558 559 560 
# File 'lib/rgeo/feature/geometry.rb', line 558 def intersection(another_geometry) raise Error::UnsupportedOperation, "Method #{self.class}#intersection not defined." end 
#intersects?(another_geometry) ⇒ Boolean
SFS 1.1 Description
Returns true if this geometric object “spatially intersects” another_geometry.
Notes
Returns a boolean value. Note that this is different from the SFS specification, which stipulates an integer return value.
Although implementations are free to attempt to handle another_geometry values that do not share the same factory as this geometry, strictly speaking, the result of comparing objects from different factories is undefined.
345 346 347 
# File 'lib/rgeo/feature/geometry.rb', line 345 def intersects?(another_geometry) raise Error::UnsupportedOperation, "Method #{self.class}#intersects? not defined." end 
#is_3d? ⇒ Boolean
SFS 1.2 Description
Returns 1 (TRUE) if this geometric object has z coordinate values.
Notes
262 263 264 
# File 'lib/rgeo/feature/geometry.rb', line 262 def is_3d? raise Error::UnsupportedOperation, "Method #{self.class}#is_3d? not defined." end 
#is_empty? ⇒ Boolean
228 229 230 231 
# File 'lib/rgeo/feature/geometry.rb', line 228 def is_empty? warn "The is_empty? method is deprecated, please use the empty? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"] empty? end 
#is_simple? ⇒ Boolean
250 251 252 253 
# File 'lib/rgeo/feature/geometry.rb', line 250 def is_simple? warn "The is_simple? method is deprecated, please use the simple? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"] simple? end 
#locate_along ⇒ RGeo::Feature::GeometryCollection
SFS 1.2 Description
Returns a derived geometry collection value that matches the specified m coordinate value.
Notes
479 480 481 
# File 'lib/rgeo/feature/geometry.rb', line 479 def locate_along raise Error::UnsupportedOperation, "Method #{self.class}#locate_along not defined." end 
#locate_between ⇒ RGeo::Feature::GeometryCollection
SFS 1.2 Description
Returns a derived geometry collection value that matches the specified range of m coordinate values inclusively
Notes
493 494 495 
# File 'lib/rgeo/feature/geometry.rb', line 493 def locate_between raise Error::UnsupportedOperation, "Method #{self.class}#locate_between not defined." end 
#measured? ⇒ Boolean
SFS 1.2 Description
Returns 1 (TRUE) if this geometric object has m coordinate values.
Notes
273 274 275 
# File 'lib/rgeo/feature/geometry.rb', line 273 def measured? raise Error::UnsupportedOperation, "Method #{self.class}#measured? not defined." end 
#overlaps?(another_geometry) ⇒ Boolean
SFS 1.1 Description
Returns true if this geometric object “spatially overlaps” another_geometry.
Notes
Returns a boolean value. Note that this is different from the SFS specification, which stipulates an integer return value.
Although implementations are free to attempt to handle another_geometry values that do not share the same factory as this geometry, strictly speaking, the result of comparing objects from different factories is undefined.
440 441 442 
# File 'lib/rgeo/feature/geometry.rb', line 440 def overlaps?(another_geometry) raise Error::UnsupportedOperation, "Method #{self.class}#overlaps? not defined." end 
#relate?(another_geometry, _intersection_pattern_matrix_) ⇒ Boolean
SFS 1.1 Description
Returns true if this geometric object is spatially related to another_geometry by testing for intersections between the interior, boundary and exterior of the two geometric objects as specified by the values in the intersection_pattern_matrix.
Notes
The intersection_pattern_matrix is provided as a ninecharacter string in rowmajor order, representing the dimensionalities of the different intersections in the DE9IM. Supported characters include T, F, *, 0, 1, and 2.
Returns a boolean value. Note that this is different from the SFS specification, which stipulates an integer return value.
Although implementations are free to attempt to handle another_geometry values that do not share the same factory as this geometry, strictly speaking, the result of comparing objects from different factories is undefined.
466 467 468 
# File 'lib/rgeo/feature/geometry.rb', line 466 def relate?(another_geometry, _intersection_pattern_matrix_) raise Error::UnsupportedOperation, "Method #{self.class}#relate not defined." end 
#rep_equals?(another_geometry) ⇒ Boolean
Returns true if this geometric object is representationally equivalent to the given object.
Although implementations are free to attempt to handle another_geometry values that do not share the same factory as this geometry, strictly speaking, the result of comparing objects from different factories is undefined.
624 625 626 
# File 'lib/rgeo/feature/geometry.rb', line 624 def rep_equals?(another_geometry) raise Error::UnsupportedOperation, "Method #{self.class}#rep_equals? not defined." end 
#simple? ⇒ Boolean
SFS 1.1 Description
Returns true if this geometric object has no anomalous geometric points, such as self intersection or self tangency. The description of each instantiable geometric class will include the specific conditions that cause an instance of that class to be classified as not simple.
Notes
Returns a boolean value. Note that this is different from the SFS specification, which stipulates an integer return value.
246 247 248 
# File 'lib/rgeo/feature/geometry.rb', line 246 def simple? raise Error::UnsupportedOperation, "Method #{self.class}#simple? not defined." end 
#spatial_dimension ⇒ Integer
SFS 1.2 Description
The spatial dimension is the dimension of the spatial portion of the direct positions (coordinate tuples) used in the definition of this geometric object. If the direct positions do not carry a measure coordinate, this will be equal to the coordinate dimension.
Notes
Similar to coordinate_dimension except it will ignore the M component always.
137 138 139 
# File 'lib/rgeo/feature/geometry.rb', line 137 def spatial_dimension raise Error::UnsupportedOperation, "Method #{self.class}#spatial_dimension not defined." end 
#srid ⇒ Object
SFS 1.1 Description
Returns the Spatial Reference System ID for this geometric object.
Notes
Returns an integer.
This will normally be a foreign key to an index of reference systems stored in either the same or some other datastore.
169 170 171 
# File 'lib/rgeo/feature/geometry.rb', line 169 def srid raise Error::UnsupportedOperation, "Method #{self.class}#srid not defined." end 
#sym_difference(another_geometry) ⇒ Object
SFS 1.1 Description
Returns a geometric object that represents the Point set symmetric difference of this geometric object with another_geometry.
Notes
Returns an object that supports the Geometry interface.
Although implementations are free to attempt to handle another_geometry values that do not share the same factory as this geometry, strictly speaking, the result of performing operations on objects from different factories is undefined.
612 613 614 
# File 'lib/rgeo/feature/geometry.rb', line 612 def sym_difference(another_geometry) raise Error::UnsupportedOperation, "Method #{self.class}#sym_difference not defined." end 
#touches?(another_geometry) ⇒ Boolean
SFS 1.1 Description
Returns true if this geometric object “spatially touches” another_geometry.
Notes
Returns a boolean value. Note that this is different from the SFS specification, which stipulates an integer return value.
Although implementations are free to attempt to handle another_geometry values that do not share the same factory as this geometry, strictly speaking, the result of comparing objects from different factories is undefined.
364 365 366 
# File 'lib/rgeo/feature/geometry.rb', line 364 def touches?(another_geometry) raise Error::UnsupportedOperation, "Method #{self.class}#touches? not defined." end 
#unary_union ⇒ Object
Unions a collection of Geometry or a single Geometry (which may be a collection) together. By using this specialpurpose operation over a collection of geometries it is possible to take advantage of various optimizations to improve performance. Heterogeneous GeometryCollections are fully supported.
This is not a standard SFS method, but when it is available in GEOS, it is a very performant way to union all the geometries in a collection. GEOS version 3.3 or greater is required. If the feature is not available, unary_union returns nil.
641 642 643 
# File 'lib/rgeo/feature/geometry.rb', line 641 def unary_union raise Error::UnsupportedOperation, "Method #{self.class}#unary_union not defined." end 
#union(another_geometry) ⇒ Object
SFS 1.1 Description
Returns a geometric object that represents the Point set union of this geometric object with another_geometry.
Notes
Returns an object that supports the Geometry interface.
Although implementations are free to attempt to handle another_geometry values that do not share the same factory as this geometry, strictly speaking, the result of performing operations on objects from different factories is undefined.
576 577 578 
# File 'lib/rgeo/feature/geometry.rb', line 576 def union(another_geometry) raise Error::UnsupportedOperation, "Method #{self.class}#union not defined." end 
#within?(another_geometry) ⇒ Boolean
SFS 1.1 Description
Returns true if this geometric object is “spatially within” another_geometry.
Notes
Returns a boolean value. Note that this is different from the SFS specification, which stipulates an integer return value.
Although implementations are free to attempt to handle another_geometry values that do not share the same factory as this geometry, strictly speaking, the result of comparing objects from different factories is undefined.
402 403 404 
# File 'lib/rgeo/feature/geometry.rb', line 402 def within?(another_geometry) raise Error::UnsupportedOperation, "Method #{self.class}#within? not defined." end 