Module: PostgisAdapter::Functions

Defined in:
lib/postgis_adapter/functions.rb,
lib/postgis_adapter/acts_as_geom.rb,
lib/postgis_adapter/functions/bbox.rb,
lib/postgis_adapter/functions/class.rb,
lib/postgis_adapter/functions/common.rb

Defined Under Namespace

Modules: ClassMethods, LineStringFunctions, MultiPolygonFunctions, PointFunctions, PolygonFunctions

Constant Summary collapse

EARTH_SPHEROID =

WGS84 Spheroid

"'SPHEROID[\"GRS-80\",6378137,298.257222101]'"

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.included(base) ⇒ Object 



8
9
10
 
# File 'lib/postgis_adapter/acts_as_geom.rb', line 8

def self.included(base)
  base.send :extend, ClassMethods
end

Instance Method Details

#as_geo_json(precision = 15, bbox = 0) ⇒ Object

Returns Geometry as GeoJSON

geojson.org/



525
526
527
 
# File 'lib/postgis_adapter/functions/common.rb', line 525

def as_geo_json(precision=15, bbox = 0)
  postgis_calculate(:AsGeoJSON, self, [precision, bbox])
end

#bbox(operator, other) ⇒ Object

These operators utilize indexes. They compare geometries by bounding boxes.

You can use the literal forms or call directly using the ‘bbox’ method. eg.:

@point.bbox(">>", @area)
@point.bbox("|&>", @area)

Cheatsheet:

A &< B    =>    A overlaps or is to the left of B
A &> B    =>    A overlaps or is to the right of B
A << B    =>    A is strictly to the left of B
A >> B    =>    A is strictly to the right of B
A &<| B   =>    A overlaps B or is below B
A |&> B   =>    A overlaps or is above B
A <<| B   =>    A strictly below B
A |>> B   =>    A strictly above B
A = B     =>    A bbox same as B bbox
A @ B     =>    A completely contained by B
A ~ B     =>    A completely contains B
A && B    =>    A and B bboxes interact
A ~= B    =>    A and B geometries are binary equal?



35
36
37
 
# File 'lib/postgis_adapter/functions/bbox.rb', line 35

def bbox(operator, other)
  postgis_calculate(:bbox, [self, other], operator)
end

#binary_equal?(other) ⇒ Boolean

bbox literal method.

Returns:

  • (Boolean) 


119
120
121
 
# File 'lib/postgis_adapter/functions/bbox.rb', line 119

def binary_equal? other
  bbox("~=", other)
end

#boundary ⇒ Object

Returns the closure of the combinatorial boundary of this Geometry. The combinatorial boundary is defined as described in section 3.12.3.2 of the OGC SPEC. Because the result of this function is a closure, and hence topologically closed, the resulting boundary can be represented using representational geometry primitives as discussed in the OGC SPEC, section 3.12.2.

Do not call with a GEOMETRYCOLLECTION as an argument.

Performed by the GEOS module.

Returns Geometry ST_Boundary(geometry geomA);



100
101
102
 
# File 'lib/postgis_adapter/functions/common.rb', line 100

def boundary
  postgis_calculate(:boundary, self)
end

#buffer(width = 0.1) ⇒ Object 



250
251
252
 
# File 'lib/postgis_adapter/functions/common.rb', line 250

def buffer(width=0.1)
  postgis_calculate(:buffer, self, width)
end

#build_area ⇒ Object

Creates an areal geometry formed by the constituent linework of given geometry. The return type can be a Polygon or MultiPolygon, depending on input. If the input lineworks do not form polygons NULL is returned. The inputs can be LINESTRINGS, MULTILINESTRINGS, POLYGONS, MULTIPOLYGONS, and GeometryCollections.

Returns Boolean ST_BuildArea(geometry A);



373
374
375
 
# File 'lib/postgis_adapter/functions/common.rb', line 373

def build_area
  postgis_calculate(:buildarea, self)
end

#centroid ⇒ Object

Computes the geometric center of a geometry, or equivalently, the center of mass of the geometry as a POINT. For [MULTI]POINTs, this is computed as the arithmetric mean of the input coordinates. For [MULTI]LINESTRINGs, this is computed as the weighted length of each line segment. For [MULTI]POLYGONs, “weight” is thought in terms of area. If an empty geometry is supplied, an empty GEOMETRYCOLLECTION is returned. If NULL is supplied, NULL is returned.

The centroid is equal to the centroid of the set of component Geometries of highest dimension (since the lower-dimension geometries contribute zero “weight” to the centroid).

Computation will be more accurate if performed by the GEOS module (enabled at compile time).

postgis.refractions.net/documentation/manual-svn/ST_Centroid.html

Returns Geometry ST_Centroid(geometry g1);



83
84
85
 
# File 'lib/postgis_adapter/functions/common.rb', line 83

def centroid
  postgis_calculate(:centroid, self)
end

#completely_contained_by?(other) ⇒ Boolean

bbox literal method.

Returns:

  • (Boolean) 


42
43
44
 
# File 'lib/postgis_adapter/functions/bbox.rb', line 42

def completely_contained_by? other
  bbox("@", other)
end

#completely_contains?(other) ⇒ Boolean

bbox literal method.

Returns:

  • (Boolean) 


49
50
51
 
# File 'lib/postgis_adapter/functions/bbox.rb', line 49

def completely_contains? other
  bbox("~", other)
end

#contains?(other) ⇒ Boolean

True if geometry B is completely inside geometry A.

For this function to make sense, the source geometries must both be of the same coordinate projection, having the same SRID. ‘contains?’ is the inverse of ‘within?’.

So a.contains?(b) is like b.within?(a) except in the case of invalid geometries where the result is always false regardless or not defined.

Do not call with a GEOMETRYCOLLECTION as an argument Do not use this function with invalid geometries. You will get unexpected results.

Performed by the GEOS module

Returns Boolean ST_Contains(geometry geomA, geometry geomB);

Returns:

  • (Boolean) 


165
166
167
 
# File 'lib/postgis_adapter/functions/common.rb', line 165

def contains? other
  postgis_calculate(:contains, [self, other])
end

#convex_hull ⇒ Object

The convex hull of a geometry represents the minimum closed geometry that encloses all geometries within the set.

It is usually used with MULTI and Geometry Collections. Although it is not an aggregate - you can use it in conjunction with ST_Collect to get the convex hull of a set of points. ST_ConvexHull(ST_Collect(somepointfield)). It is often used to determine an affected area based on a set of point observations.

Performed by the GEOS module.

Returns Geometry ST_ConvexHull(geometry geomA);



361
362
363
 
# File 'lib/postgis_adapter/functions/common.rb', line 361

def convex_hull
  postgis_calculate(:convexhull, self)
end

#covered_by?(other) ⇒ Boolean Also known as: inside?

True if no point in Geometry A is outside Geometry B

This function call will automatically include a bounding box comparison that will make use of any indexes that are available on the geometries. To avoid index use, use the function _ST_CoveredBy.

Do not call with a GEOMETRYCOLLECTION as an argument. Do not use this function with invalid geometries. You will get unexpected results.

Performed by the GEOS module.

Aliased as ‘inside?’

Returns Boolean ST_CoveredBy(geometry geomA, geometry geomB);

Returns:

  • (Boolean) 


185
186
187
 
# File 'lib/postgis_adapter/functions/common.rb', line 185

def covered_by? other
  postgis_calculate(:coveredby, [self, other])
end

#d_within?(other, margin = 0.1) ⇒ Boolean Also known as: in_bounds?

True if the geometries are within the specified distance of one another. The distance is specified in units defined by the spatial reference system of the geometries. For this function to make sense, the source geometries must both be of the same coorindate projection, having the same SRID.

Returns boolean ST_DWithin(geometry g1, geometry g2, double precision distance);

Returns:

  • (Boolean) 


144
145
146
 
# File 'lib/postgis_adapter/functions/common.rb', line 144

def d_within?(other, margin=0.1)
  postgis_calculate(:dwithin, [self, other], margin)
end

#dimension ⇒ Object

How many dimensions the geom is made of (2, 3 or 4)

Returns Integer ST_Dimension(geom g1)



220
221
222
 
# File 'lib/postgis_adapter/functions/common.rb', line 220

def dimension
  postgis_calculate(:dimension, self).to_i
end

#disjoint?(other) ⇒ Boolean

True if the Geometries do not “spatially intersect” - if they do not share any space together.

Overlaps, Touches, Within all imply geometries are not spatially disjoint. If any of the aforementioned returns true, then the geometries are not spatially disjoint. Disjoint implies false for spatial intersection.

Do not call with a GEOMETRYCOLLECTION as an argument.

Returns boolean ST_Disjoint( geometry A , geometry B );

Returns:

  • (Boolean) 


211
212
213
 
# File 'lib/postgis_adapter/functions/common.rb', line 211

def disjoint? other
  postgis_calculate(:disjoint, [self, other])
end

#distance_to(other) ⇒ Object

2D minimum cartesian distance between two geometries in projected units.

Returns Float ST_Distance(geometry g1, geometry g2);



109
110
111
 
# File 'lib/postgis_adapter/functions/common.rb', line 109

def distance_to(other)
  postgis_calculate(:distance, [self, other]).to_f
end

#envelope ⇒ Object

Returns the minimum bounding box for the supplied geometry, as a geometry. The polygon is defined by the corner points of the bounding box ((MINX, MINY), (MINX, MAXY), (MAXX, MAXY), (MAXX, MINY), (MINX, MINY)). PostGIS will add a ZMIN/ZMAX coordinate as well/

Degenerate cases (vertical lines, points) will return a geometry of lower dimension than POLYGON, ie. POINT or LINESTRING.

In PostGIS, the bounding box of a geometry is represented internally using float4s instead of float8s that are used to store geometries. The bounding box coordinates are floored, guarenteeing that the geometry is contained entirely within its bounds. This has the advantage that a geometry’s bounding box is half the size as the minimum bounding rectangle, which means significantly faster indexes and general performance. But it also means that the bounding box is NOT the same as the minimum bounding rectangle that bounds the geome.

Returns GeometryCollection ST_Envelope(geometry g1);



60
61
62
 
# File 'lib/postgis_adapter/functions/common.rb', line 60

def envelope
  postgis_calculate(:envelope, self)
end

#envelopes_intersect?(other) ⇒ Boolean

True if a Geometry`s Envelope “spatially intersect”, share any portion of space.

It`s ‘intersects?’, for envelopes.

Returns Boolean SE_EnvelopesIntersect(geometry geomA, geometry geomB);

Returns:

  • (Boolean) 


290
291
292
 
# File 'lib/postgis_adapter/functions/common.rb', line 290

def envelopes_intersect? other
   postgis_calculate(:se_envelopesintersect, [self, other])
end

#geo_columns ⇒ Object 



28
29
30
 
# File 'lib/postgis_adapter/functions.rb', line 28

def geo_columns
  @geo_columns ||= postgis_geoms[:columns]
end

#interacts_with?(other) ⇒ Boolean

bbox literal method.

Returns:

  • (Boolean) 


112
113
114
 
# File 'lib/postgis_adapter/functions/bbox.rb', line 112

def interacts_with? other
  bbox("&&", other)
end

#intersection(other) ⇒ Object

Geometry that represents the point set intersection of the Geometries. In other words - that portion of geometry A and geometry B that is shared between the two geometries. If the geometries do not share any space (are disjoint), then an empty geometry collection is returned.

‘intersection’ in conjunction with intersects? is very useful for clipping geometries such as in bounding box, buffer, region queries where you only want to return that portion of a geometry that sits in a country or region of interest.

Do not call with a GEOMETRYCOLLECTION as an argument. Performed by the GEOS module.

Returns Geometry ST_Intersection(geometry geomA, geometry geomB);



309
310
311
 
# File 'lib/postgis_adapter/functions/common.rb', line 309

def intersection other
  postgis_calculate(:intersection, [self, other])
end

#intersects?(other) ⇒ Boolean

True if Geometries “spatially intersect”, share any portion of space. False if they don’t (they are Disjoint).

‘overlaps?’, ‘touches?’, ‘within?’ all imply spatial intersection. If any of the aforementioned returns true, then the geometries also spatially intersect. ‘disjoint?’ implies false for spatial intersection.

Returns Boolean ST_Intersects(geometry geomA, geometry geomB);

Returns:

  • (Boolean) 


279
280
281
 
# File 'lib/postgis_adapter/functions/common.rb', line 279

def intersects? other
  postgis_calculate(:intersects, [self, other])
end

#is_simple? ⇒ Boolean Also known as: simple?

Returns true if this Geometry has no anomalous geometric points, such as self intersection or self tangency.

Returns boolean ST_IsSimple(geometry geomA);

Returns:

  • (Boolean) 


383
384
385
 
# File 'lib/postgis_adapter/functions/common.rb', line 383

def is_simple?
  postgis_calculate(:issimple, self)
end

#outside?(other) ⇒ Boolean

Eye-candy. See ‘covered_by?’.

Returns !(Boolean ST_CoveredBy(geometry geomA, geometry geomB);)

Returns:

  • (Boolean) 


195
196
197
 
# File 'lib/postgis_adapter/functions/common.rb', line 195

def outside? other
  !covered_by? other
end

#overlaps?(other) ⇒ Boolean

True if the Geometries share space, are of the same dimension, but are not completely contained by each other. They intersect, but one does not completely contain another.

Do not call with a GeometryCollection as an argument This function call will automatically include a bounding box comparison that will make use of any indexes that are available on the geometries. To avoid index use, use the function _ST_Overlaps.

Performed by the GEOS module.

Returns Boolean ST_Overlaps(geometry A, geometry B);

Returns:

  • (Boolean) 


327
328
329
 
# File 'lib/postgis_adapter/functions/common.rb', line 327

def overlaps? other
  postgis_calculate(:overlaps, [self, other])
end

#overlaps_or_above?(other) ⇒ Boolean

bbox literal method.

Returns:

  • (Boolean) 


56
57
58
 
# File 'lib/postgis_adapter/functions/bbox.rb', line 56

def overlaps_or_above? other
  bbox("|&>", other)
end

#overlaps_or_below?(other) ⇒ Boolean

bbox literal method.

Returns:

  • (Boolean) 


63
64
65
 
# File 'lib/postgis_adapter/functions/bbox.rb', line 63

def overlaps_or_below? other
  bbox("&<|", other)
end

#overlaps_or_left_of?(other) ⇒ Boolean

bbox literal method.

Returns:

  • (Boolean) 


70
71
72
 
# File 'lib/postgis_adapter/functions/bbox.rb', line 70

def overlaps_or_left_of? other
  bbox("&<", other)
end

#overlaps_or_right_of?(other) ⇒ Boolean

bbox literal method.

Returns:

  • (Boolean) 


77
78
79
 
# File 'lib/postgis_adapter/functions/bbox.rb', line 77

def overlaps_or_right_of? other
  bbox("&>", other)
end

#point_on_surface ⇒ Object

ST_PointOnSurface — Returns a POINT guaranteed to lie on the surface.

geometry ST_PointOnSurface(geometry g1);eometry A, geometry B);



534
535
536
 
# File 'lib/postgis_adapter/functions/common.rb', line 534

def point_on_surface
  postgis_calculate(:pointonsurface, self)
end

#polygonize ⇒ Object

Aggregate. Creates a GeometryCollection containing possible polygons formed from the constituent linework of a set of geometries.

Geometry Collections are often difficult to deal with with third party tools, so use ST_Polygonize in conjunction with ST_Dump to dump the polygons out into

individual polygons.

Returns Geometry ST_Polygonize(geometry set geomfield);



398
399
400
 
# File 'lib/postgis_adapter/functions/common.rb', line 398

def polygonize
  postgis_calculate(:polygonize, self)
end

#postgis_calculate(operation, subjects, options = {}) ⇒ Object

SRID => 4326



23
24
25
26
 
# File 'lib/postgis_adapter/functions.rb', line 23

def postgis_calculate(operation, subjects, options = {})
  subjects = [subjects] unless subjects.respond_to?(:map)
  execute_geometrical_calculation(operation, subjects, options)
end

#relate?(other, m = nil) ⇒ Boolean

Returns true if this Geometry is spatially related to anotherGeometry, by testing for intersections between the Interior, Boundary and Exterior of the two geometries as specified by the values in the intersectionPatternMatrix. If no intersectionPatternMatrix is passed in, then returns the maximum intersectionPatternMatrix that relates the 2 geometries.

Version 1: Takes geomA, geomB, intersectionMatrix and Returns 1 (TRUE) if this Geometry is spatially related to anotherGeometry, by testing for intersections between the Interior, Boundary and Exterior of the two geometries as specified by the values in the intersectionPatternMatrix.

This is especially useful for testing compound checks of intersection, crosses, etc in one step.

Do not call with a GeometryCollection as an argument

This is the “allowable” version that returns a boolean, not an integer. This is defined in OGC spec. This DOES NOT automagically include an index call. The reason for that is some relationships are anti e.g. Disjoint. If you are using a relationship pattern that requires intersection, then include the && index call.

Version 2: Takes geomA and geomB and returns the DE-9IM (dimensionally extended nine-intersection matrix)

Do not call with a GeometryCollection as an argument Not in OGC spec, but implied. see s2.1.13.2

Both Performed by the GEOS module

Returns:

String ST_Relate(geometry geomA, geometry geomB);
Boolean ST_Relate(geometry geomA, geometry geomB, text intersectionPatternMatrix);

Returns:

  • (Boolean) 


439
440
441
442
443
 
# File 'lib/postgis_adapter/functions/common.rb', line 439

def relate?(other, m = nil)
  # Relate is case sentitive.......
  m = "'#{m}'" if m
  postgis_calculate("Relate", [self, other], m)
end

#same_as?(other) ⇒ Boolean

bbox literal method.

Returns:

  • (Boolean) 


126
127
128
 
# File 'lib/postgis_adapter/functions/bbox.rb', line 126

def same_as? other
  bbox("=", other)
end

#segmentize(max_length = 1.0) ⇒ Object

Returns a modified geometry having no segment longer than the given distance. Distance computation is performed in 2d only.

This will only increase segments. It will not lengthen segments shorter than max length

Return Geometry ST_Segmentize(geometry geomA, float max_length);



472
473
474
 
# File 'lib/postgis_adapter/functions/common.rb', line 472

def segmentize(max_length=1.0)
  postgis_calculate("segmentize", self, max_length)
end

#simplify(tolerance = 0.1) ⇒ Object

Returns a “simplified” version of the given geometry using the Douglas-Peuker algorithm. Will actually do something only with (multi)lines and (multi)polygons but you can safely call it with any kind of geometry. Since simplification occurs on a object-by-object basis you can also feed a GeometryCollection to this function.

Note that returned geometry might loose its simplicity (see ‘is_simple?’). Topology may not be preserved and may result in invalid geometries. Use ‘simplify_preserve_topology’ to preserve topology.

Performed by the GEOS Module.

Returns Geometry ST_Simplify(geometry geomA, float tolerance);



239
240
241
 
# File 'lib/postgis_adapter/functions/common.rb', line 239

def simplify(tolerance=0.1)
  postgis_calculate(:simplify, self, tolerance)
end

#simplify!(tolerance = 0.1) ⇒ Object 



243
244
245
246
 
# File 'lib/postgis_adapter/functions/common.rb', line 243

def simplify!(tolerance=0.1)
  #FIXME: not good..
  self.update_attribute(geo_columns.first, simplify)
end

#simplify_preserve_topology(tolerance = 0.1) ⇒ Object

Returns a “simplified” version of the given geometry using the Douglas-Peuker algorithm. Will avoid creating derived geometries (polygons in particular) that are invalid. Will actually do something only with (multi)lines and (multi)polygons but you can safely call it with any kind of geometry. Since simplification occurs on a object-by-object basis you can also feed a GeometryCollection to this function.

Performed by the GEOS module. Requires GEOS 3.0.0+

Returns Geometry ST_SimplifyPreserveTopology(geometry geomA, float tolerance);



265
266
267
 
# File 'lib/postgis_adapter/functions/common.rb', line 265

def simplify_preserve_topology(tolerance=0.1)
  postgis_calculate(:simplifypreservetopology, self, tolerance)
end

#spatially_equal?(other) ⇒ Boolean

True if the given geometries represent the same geometry. Directionality is ignored.

Returns TRUE if the given Geometries are “spatially equal”. Use this for a ‘better’ answer than ‘=’. Note by spatially equal we mean ST_Within(A,B) = true and ST_Within(B,A) = true and also mean ordering of points can be different but represent the same geometry structure. To verify the order of points is consistent, use ST_OrderingEquals (it must be noted ST_OrderingEquals is a little more stringent than simply verifying order of points are the same).

This function will return false if either geometry is invalid even if they are binary equal.

Returns Boolean ST_Equals(geometry A, geometry B);

Returns:

  • (Boolean) 


36
37
38
 
# File 'lib/postgis_adapter/functions/common.rb', line 36

def spatially_equal?(other)
  postgis_calculate(:equals, [self, other])
end

#srid ⇒ Object

Returns the instance`s geom srid



479
480
481
 
# File 'lib/postgis_adapter/functions/common.rb', line 479

def srid
  self[postgis_geoms.keys.first].srid
end

#st_collect(other = nil) ⇒ Object 



345
346
347
 
# File 'lib/postgis_adapter/functions/common.rb', line 345

def st_collect(other=nil)
  postgis_calculate(:collect, [self, other])
end

#strictly_above?(other) ⇒ Boolean

bbox literal method.

Returns:

  • (Boolean) 


84
85
86
 
# File 'lib/postgis_adapter/functions/bbox.rb', line 84

def strictly_above? other
  bbox("|>>", other)
end

#strictly_below?(other) ⇒ Boolean

bbox literal method.

Returns:

  • (Boolean) 


91
92
93
 
# File 'lib/postgis_adapter/functions/bbox.rb', line 91

def strictly_below? other
  bbox("<<|", other)
end

#strictly_left_of?(other) ⇒ Boolean

bbox literal method.

Returns:

  • (Boolean) 


98
99
100
 
# File 'lib/postgis_adapter/functions/bbox.rb', line 98

def strictly_left_of? other
  bbox("<<", other)
end

#strictly_right_of?(other) ⇒ Boolean

bbox literal method.

Returns:

  • (Boolean) 


105
106
107
 
# File 'lib/postgis_adapter/functions/bbox.rb', line 105

def strictly_right_of? other
  bbox(">>", other)
end

#to_utm ⇒ Object 



516
517
518
 
# File 'lib/postgis_adapter/functions/common.rb', line 516

def to_utm
  dup.to_utm!
end

#to_utm!(utm = nil) ⇒ Object

Returns the Geometry in its UTM Zone

Return Geometry



511
512
513
514
 
# File 'lib/postgis_adapter/functions/common.rb', line 511

def to_utm!(utm=nil)
  utm ||= utm_zone
  self[postgis_geoms.keys.first] = transform(utm)
end

#touches?(other) ⇒ Boolean

True if the geometries have at least one point in common, but their interiors do not intersect.

If the only points in common between g1 and g2 lie in the union of the boundaries of g1 and g2. The ‘touches?’ relation applies to all Area/Area, Line/Line, Line/Area, Point/Area and Point/Line pairs of relationships, but not to the Point/Point pair.

Returns Boolean ST_Touches(geometry g1, geometry g2);

Returns:

  • (Boolean) 


341
342
343
 
# File 'lib/postgis_adapter/functions/common.rb', line 341

def touches? other
  postgis_calculate(:touches, [self, other])
end

#transform(new_srid) ⇒ Object 



460
461
462
 
# File 'lib/postgis_adapter/functions/common.rb', line 460

def transform(new_srid)
  dup.transform!(new_srid)
end

#transform!(new_srid) ⇒ Object

Transform the geometry into a different spatial reference system. The destination SRID must exist in the SPATIAL_REF_SYS table.

This method implements the OpenGIS Simple Features Implementation Specification for SQL. This method supports Circular Strings and Curves (PostGIS 1.3.4+)

Requires PostGIS be compiled with Proj support.

Return Geometry ST_Transform(geometry g1, integer srid);



456
457
458
 
# File 'lib/postgis_adapter/functions/common.rb', line 456

def transform!(new_srid)
  self[postgis_geoms.keys[0]] = postgis_calculate("Transform", self.new_record? ? self.geom : self, new_srid)
end

#utm_zone ⇒ Object

Return UTM Zone for a geom

Return Integer



487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
 
# File 'lib/postgis_adapter/functions/common.rb', line 487

def utm_zone
  if srid == 4326
    geom = centroid
  else
    geomdup = transform(4326)
    mezzo = geomdup.length / 2
    geom = case geomdup
           when Point      then  geomdup
           when LineString then  geomdup[mezzo]
           else
             geomgeog[mezzo][geomgeo[mezzo]/2]
           end

  end

  pref = geom.y > 0 ? 32700 : 32600
  zone = ((geom.x + 180) / 6 + 1).to_i
  zone + pref
end

#valid_geom? ⇒ Boolean

Test if a geometry is well formed.

Returns:

  • (Boolean) 


15
16
17
 
# File 'lib/postgis_adapter/functions/common.rb', line 15

def valid_geom?
  postgis_calculate(:isvalid, self)
end

#within?(other) ⇒ Boolean

True if geometry A is completely inside geometry B.

For this function to make sense, the source geometries must both be of the same coordinate projection, having the same SRID. It is a given that if ST_Within(A,B) is true and ST_Within(B,A) is true, then the two geometries are considered spatially equal.

This function call will automatically include a bounding box comparison that will make use of any indexes that are available on the geometries. To avoid index use, use the function _ST_Within.

Do not call with a GEOMETRYCOLLECTION as an argument Do not use this function with invalid geometries. You will get unexpected results.

Performed by the GEOS module.

Returns Boolean ST_Within(geometry A, geometry B);

Returns:

  • (Boolean) 


132
133
134
 
# File 'lib/postgis_adapter/functions/common.rb', line 132

def within? other
  postgis_calculate(:within, [self, other])
end