PostGIS is developed by Refractions Research Inc, as a spatial database
technology research project. Refractions is a GIS and database
consulting company in Victoria, British Columbia, Canada, specializing in data
integration and custom software development. We plan on supporting and
developing PostGIS to support a range of important GIS functionality, including
full OpenGIS support, advanced topological constructs (coverages, surfaces,
networks), desktop user interface tools for viewing and editing GIS data, and
web-based access tools.
The principal developer of PostGIS. Dave maintains the server
side objects and index support, the server side analytical
functions, and the Mapserver connectivity.
Chris Hodgson <chodgson@refractions.net>
Maintains new functions and the 7.2 index bindings.
Paul Ramsey <pramsey@refractions.net>
Maintains the JDBC objects and keeps track of the
documentation and packaging.
You can store point, line, polygon, multipoint, multiline,
multipolygon, and geometrycollections. These are specified in
the Open GIS Well Known Text Format (with 3d extentions).
2. How do I insert a GIS object into the database?
First, you need to create a table with a column of type
"geometry" to hold your GIS data. Connect to your database with
psql and try the following SQL:
CREATE TABLE gtest ( ID int4, NAME varchar(20) );
SELECT AddGeometryColumn('dbname','gtest','geom',-1,'LINESTRING',2);
If the geometry column addition fails, you probably have not
loaded the PostGIS functions and objects into this database. See the
installation instructions.
Then, you can insert a geometry into the table using a SQL
insert statement. The GIS object itself is formatted using the
OpenGIS Consortium "well-known text" format:
For more information about other GIS objects, see the
object reference.
To view your GIS data in the table:
SELECT id, name, AsText(geom) AS geom FROM gtest;
The return value should look something like this:
id | name | geom
----+----------------+-----------------------------
1 | First Geometry | LINESTRING(2 3,4 5,6 5,7 8)
(1 row)
3. How do I construct a spatial query?
There are a number of spatial operators available to
PostgreSQL, and several of them have been implemented by PostGIS
in order to provide indexing support.
In order to do a spatial query with index support, you must
use the "overlap operator" (&&) which uses the following
important simplifying assumption: all features shall be
represented by their bounding boxes.
We recognize that using bounding boxes to proxy for features is
a limiting assumption, but it is an important one in providing
spatial indexing capabilities. Commercial spatial databases use
the same assumption -- bounding boxes are important to most
spatial indexing schemes.
The most important spatial operator from a user's perspective
is the "&&" overlap operator, which tests whether one
feature's bounding box overlaps that of another. An example of a
spatial query using && is:
SELECT id,name FROM GTEST WHERE GEOM && 'BOX3D(3 4,4 5)'::box3d
Note that the bounding box used for querying must be
explicitly declared as a box3d using the
"::box3d" casting operation.
4. How do I speed up spatial queries on large tables?
Fast queries on large tables is the raison
d'etre of spatial databases (along with transaction
support) so having a good index in important.
To build a spatial index on a table with a
geometry column, use the "CREATE INDEX"
function as follows:
CREATE INDEX [indexname] ON [tablename]
USING GIST ( [geometrycolumn] gist_geometry_ops);
The "USING GIST" option tells the server to use a GiST
(Generalized Search Tree) index. The reference to
"gist_geometry_ops" tells the server to use a particular set
of comparison operators for building the index: the
"gist_geometry_ops" are part of the PostGIS extension.
Note: For PostgreSQL version 7.1.x, you can specifically
request a "lossy" index by appending WITH (ISLOSSY) to
the index creation command. For PostgreSQL 7.2.x and
above all GiST indexes are assumed to be lossy. Lossy
indexes uses a proxy object (in the spatial case, a
bounding box) for building the index.
Early versions of PostGIS used the PostgreSQL R-Tree
indexes. However, PostgreSQL R-Trees have been completely
discarded since version 0.6, and spatial indexing is provided
with an R-Tree-over-GiST scheme.
Our tests have shown search speed for native R-Tree and
GiST to be comparable. Native PostgreSQL R-Trees have two
limitations which make them undesirable for use with GIS
features (note that these limitations are due to the current
PostgreSQL native R-Tree implementation, not the R-Tree
concept in general):
R-Tree indexes in PostgreSQL cannot handle features
which are larger than 8K in size. GiST indexes can, using
the "lossy" trick of substituting the bounding box for
the feature itself.
R-Tree indexes in PostgreSQL are not "null safe", so
building an index on a geometry column which contains
null geometries will fail.
6. Why should I use the AddGeometryColumn()
function and all the other OpenGIS stuff?
If you do not want to use the OpenGIS support functions,
you do not have to. Simply create tables as in older versions,
defining your geometry columns in the CREATE statement. All
your geometries will have SRIDs of -1, and the OpenGIS meta-data
tables will not be filled in properly.
However, this will cause most applications based on PostGIS to
fail, and it is generally suggested that you do use
AddGeometryColumn() to create geometry tables.
Mapserver is one application which makes use of the
geometry_columns meta-data. Specifically,
Mapserver can use the SRID of the geometry column to do on-the-fly
reprojection of features into the correct map projection.
7. What is the best way to find all objects within a radius of
another object?
To use the database most efficiently, it is best to do
radius queries which combine the radius test with a bounding
box test: the bounding box test uses the spatial index, giving
fast access to a subset of data which the radius test is then
applied to.
For example, to find all objects with 100 meters of
POINT(1000 1000) the following query would work well:
SELECT *
FROM GEOTABLE
WHERE
GEOM && GeometryFromText('BOX3D(900 900,1100 1100)',-1)
AND
Distance(GeometryFromText('POINT(1000 1000)',-1),GEOM) < 100;
8. How do I perform a coordinate reprojection as part of
a query?
To perform a reprojection, both the source and
destination coordinate systems must be defined in the
SPATIAL_REF_SYS table, and the geometries being reprojected
must already have an SRID set on them. Once that is done, a
reprojection is as simple as referring to the desired
destination SRID.
The GIS objects supported by PostGIS are the "Simple Features"
defined by the OpenGIS Consortium (OGC). Note that PostGIS currently supports
the features and the representation APIs, but not the various comparison and
convolution operators given in the OGC "Simple Features for SQL"
specification.
Examples of the text representations of the features are as
follows:
Note that in the examples above there are features with both
2-dimensional and 3-dimensional coordinates. PostGIS supports both 2d and 3d
coordinates -- if you describe a feature with 2D coordinates when you insert
it, the database will return that feature to you with 2D coordinates when you
extract it. See the sections on the force_2d()
and force_3d() functions for information on
converting features to a particular coordinate dimension representation.
The OpenGIS specification defines two standard ways of expressing
spatial objects: the Well-Known Text (WKT) form (shown in the previous
section) and the Well-Known Binary (WKB) form. Both WKT and WKB
include information about the type of the object and the coordinates
which form the object.
However, the OpenGIS specification also requires that the
internal storage format of spatial objects include a spatial
referencing system identifier (SRID). The SRID is required when
creating spatial objects for insertion into the database. For
example, a valid insert statement to create and insert a spatial
object would be:
INSERT INTO SPATIALTABLE ( THE_GEOM, THE_NAME )
VALUES (
GeometryFromText('POINT(-126.4 45.32)', 312),
'A Place'
)
Note that the "GeometryFromText" function requires an SRID
number.
The "canonical form" of the spatial objects in PostgreSQL is a
text representation which includes all the information necessary
to construct the object. Unlike the OpenGIS standard forms, it
includes the type, coordinate, and SRID information. The canonical
form is the default form returned from a SELECT query. The example
below shows the difference between the OGC standard and PostGIS
canonical forms:
db=> SELECT AsText(geom) AS OGCGeom FROM thetable;
OGCGeom
-------------------------------------------------
LINESTRING(-123.741378393049 48.9124018962261,-123.741587115639 48.9123981907507)
(1 row)
db=> SELECT geom AS PostGISGeom FROM thetable;
PostGISGeom
-------------------------------------------------
SRID=123;LINESTRING(-123.741378393049 48.9124018962261,-123.741587115639 48.9123981907507)
(1 row)
PostGIS has the following requirements for building and usage:
A complete configured and built PostgreSQL source code tree.
PostGIS uses definitions from the PostgreSQL configure/build process
to conform to the particular platform you are building on.
PostgreSQL is available from
http://www.postgresql.org.
GNU C compiler (gcc). Some other ANSI C
compilers can be used to compile PostGIS, but we find far fewer
problems when compiling with gcc.
GNU Make (gmake or make).
For many systems, GNU make is the default version
of make. Check the version by invoking make -v.
Other versions of make may not process the
PostGIS Makefile properly.
(Optional) Proj4 reprojection library. The Proj4 library is used
to provide coordinate reprojection support within PostGIS. Proj4 is
available for download from
http://www.remotesensing.org/proj.
The functions given below are the ones which a user of PostGIS is
likely to need. There are other functions which are required support functions
to the PostGIS objects which are not of use to a general user.
Syntax: AddGeometryColumn(<db_name>,
<table_name>, <column_name>, <srid>, <type>,
<dimension>). Adds a geometry column to an existing table of attributes.
The dbname is the name of the database instance.
The srid must be an integer value reference to an
entry in the SPATIAL_REF_SYS table. The type must
be an uppercase string corresponding to the geometry type, eg, 'POLYGON'
or 'MULTILINESTRING'.
DropGeometryColumn(varchar, varchar, varchar)
Syntax: DropGeometryColumn(<db_name>, <table_name>,
<column_name>). Remove a geometry column from a spatial table.
AsBinary(geometry)
Returns the geometry in the OGC "well-known-binary" format,
using the endian encoding of the server on which the database is
running. This is useful in binary cursors to pull data out of
the database without converting it to a string representation.
OGC SPEC s2.1.1.1 - also see asBinary(<geometry>,'XDR') and asBinary(<geometry>,'NDR')
Dimension(geometry)
The inherent dimension of this Geometry object, which must be less than or equal
to the coordinate dimension. OGC SPEC s2.1.1.1 - returns 0 for points, 1 for lines, 2 for polygons, and the largest dimension of the components of a GEOMETRYCOLLECTION.
Returns 1 (TRUE) if this Geometry is the empty geometry . If true, then this
Geometry represents the empty point set - i.e. GEOMETRYCOLLECTION(EMPTY).
OGC SPEC s2.1.1.1
isSimple(geometry)
Returns 1 (TRUE) if this Geometry has no anomalous geometric points, such as self
intersection or self tangency.
Performed by the GEOS module
OGC SPEC s2.1.1.1
boundary(geometry)
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.
Performed by the GEOS module
OGC SPEC s2.1.1.1
equals(geometry)
Returns 1 (TRUE) if this Geometry is "spatially equal" to
anotherGeometry. Use this for a 'better' answer than '='. equals ('LINESTRING(0 0, 10 10)','LINESTRING(0 0, 5 5, 10 10)') is true.
Performed by the GEOS module
OGC SPEC s2.1.1.1
disjoint(geometry,geometry)
Returns 1 (TRUE) if this Geometry is "spatially disjoint" from anotherGeometry.
Performed by the GEOS module
Do not call with a GeometryCollection as an argument
NOTE: this is the "allowable" version that returns a boolean, not an integer.
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.
Performed by the GEOS module
Do not call with a GeometryCollection as an argument
NOTE: this is the "allowable" version that returns a boolean, not an integer.
OGC SPEC s2.1.1.1 // s2.1.13.3
relate(geometry,geometry)
returns the DE-9IM (dimensionally extended nine-intersection matrix)
Performed by the GEOS module
Do not call with a GeometryCollection as an argument
not in OGC spec, but implied. see s2.1.13.2
buffer(geometry,double)
Returns a geometry that represents all points whose distance from
this Geometry is less than or equal to distance. Calculations are in the Spatial Reference System of this
Geometry.
Performed by the GEOS module
Do not call with a GeometryCollection as an argument
OGC SPEC s2.1.1.1
convexhull(geometry)
Returns a geometry that represents the convex hull of this Geometry.
Performed by the GEOS module
OGC SPEC s2.1.1.1
intersection(geometry,geometry)
Returns a geometry that represents the point set
intersection of this Geometry with anotherGeometry.
Performed by the GEOS module
Do not call with a GeometryCollection as an argument
OGC SPEC s2.1.1.1
GeomUnion(geometry,geometry)
Returns a geometry that represents the point set union of
this Geometry with anotherGeometry.
Performed by the GEOS module
Do not call with a GeometryCollection as an argument
NOTE: this is renamed from "union" because union is an SQL reserved word
OGC SPEC s2.1.1.1
GeomUnion(geometry set)
Returns a geometry that represents the point set union of
this all Geometries in given set.
Performed by the GEOS module
Do not call with a GeometryCollection in the argument set
Not explicitly defined in OGC SPEC
memGeomUnion(geometry set)
Same as the above, only memory-friendly (uses less memory and more processor time).
difference(geometry,geometry)
Returns a geometry that represents the point set
difference of this Geometry with anotherGeometry.
Performed by the GEOS module
Do not call with a GeometryCollection as an argument
OGC SPEC s2.1.1.1
difference(geometry,geometry)
Returns a geometry that represents the point set
symmetric difference of this Geometry with anotherGeometry.
Performed by the GEOS module
Do not call with a GeometryCollection as an argument
OGC SPEC s2.1.1.1
Envelope(geometry)
Returns a POLYGON representing the bounding box of the
geometry.
OGC SPEC s2.1.1.1 - 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)).
NOTE:PostGIS will add a Zmin/Zmax coordinate as well.
GeometryType(geometry)
Returns the type of the geometry as a string. Eg: 'LINESTRING',
'POLYGON', 'MULTIPOINT', etc.
OGC SPEC s2.1.1.1 - Returns the name of the instantiable subtype of Geometry of which this
Geometry instance is a member. The name of the instantiable subtype of Geometry is returned as a string.
X(geometry)
Find and return the X coordinate of the first point in the
geometry. Return NULL if there is no point in the geometry.
Y(geometry)
Find and return the Y coordinate of the first point in the
geometry. Return NULL if there is no point in the geometry.
Z(geometry)
Find and return the Z coordinate of the first point in the
geometry. Return NULL if there is no point in the geometry.
NumPoints(geometry)
Find and return the number of points in the first linestring
in the geometry. Return NULL if there is no linestring in the geometry.
PointN(geometry,integer)
Return the N'th point in the first linestring in the
geometry. Return NULL if there is no linestring in the geometry.
ExteriorRing(geometry)
Return the exterior ring of the first polygon in the
geometry. Return NULL if there is no polygon in the geometry.
NumInteriorRings(geometry)
Return the number of interior rings of the first polygon in
the geometry. Return NULL if there is no polygon in the geometry.
InteriorRingN(geometry,integer)
Return the N'th interior ring of the first polygon in the
geometry. Return NULL if there is no polygon in the geometry.
IsClosed(geometry)
Returns true of the geometry start and
end points are coincident.
IsRing(geometry)
Returns 1 (TRUE) if this Curve is closed (StartPoint ( ) = EndPoint ( )) and this Curve
is simple (does not pass through the same point more than once).
performed by GEOS
OGC spec 2.1.5.1
NumGeometries(geometry)
If geometry is a GEOMETRYCOLLECTION (or MULTI*) return the number of
geometries, otherwise return NULL.
GeometryN(geometry,int)
Return the N'th geometry if the geometry is a
GEOMETRYCOLLECTION, MULTIPOINT, MULTILINESTRING or
MULTIPOLYGON. Otherwise, return NULL.
0 is 1st geometry
Distance(geometry,geometry)
Return the cartesian distance between two geometries
in projected units.
AsText(geometry)
Return the Well-Known Text representation of the
geometry. For example: POLYGON(0 0,0 1,1 1,1 0,0 0)
OGC SPEC s2.1.1.1
SRID(geometry)
Returns the integer SRID number of the spatial
reference system of the geometry.
OGC SPEC s2.1.1.1
GeometryFromText(varchar, integer)
Syntax: GeometryFromText(<geometry>,<SRID>)
Convert a Well-Known Text representation of a geometry
into a geometry object.
GeomFromText(varchar, integer)
As above. A synonym for GeometryFromText.
SetSRID(geometry)
Set the SRID on a geometry to a particular integer
value. Useful in constructing bounding boxes for queries.
EndPoint(geometry)
Returns the last point of the geometry as a point.
StartPoint(geometry)
Returns the first point of the geometry as a point.
Centroid(geometry)
Returns the centroid of the geometry as a point.
Computation will be more accurate if performed by the GEOS module (enabled at compile time).
PostGIS is an extension to the PostgreSQL object-relational database system
which allows GIS (Geographic Information Systems) objects to be stored in the
database. PostGIS includes support for GiST-based R-Tree spatial indexes, and
functions for basic analysis of GIS objects.
The JDBC extensions provide Java objects corresponding to the
internal PostGIS types. These objects can be used to write Java clients
which query the PostGIS database and draw or do calculations on the GIS
data in PostGIS.
Enter the jdbc sub-directory of the
PostGIS distribution.
Edit the Makefile to provide the correct
paths of your java compiler (JAVAC) and
interpreter (JAVA).
Run the make command. Copy the
postgis.jar file to wherever you keep your
java libraries.
The data loader and dumper are built and installed automatically
as part of the PostGIS build. To build and install them manually:
# cd postgis-0.8.0/loader
# make
# make install
The loader is called shp2pgsql and converts
ESRI Shape files into SQL suitable for loading in PostGIS/PostgreSQL.
The dumper is called pgsql2shp and converts
PostGIS tables into ESRI shape files.
The OpenGIS "Simple Features Specification for SQL" defines
standard GIS object types, the functions required to manipulate them,
and a set of meta-data tables. In order to ensure that meta-data
remain consistent, operations such as creating and removing a spatial
column are carried out through special procedures defined by OpenGIS.
There are two OpenGIS meta-data tables: SPATIAL_REF_SYS and
GEOMETRY_COLUMNS. The SPATIAL_REF_SYS table holds the numeric IDs and textual
descriptions of coordinate systems used in the spatial database.
An integer value that uniquely identifies the Spatial
Referencing System within the database.
AUTH_NAME
The name of the standard or standards body that is being
cited for this reference system. For example, "EPSG" would
be a valid AUTH_NAME.
AUTH_SRID
The ID of the Spatial Reference System as defined by the
Authority cited in the AUTH_NAME. In the case of EPSG, this
is where the EPSG projection code would go.
SRTEXT
The Well-Known Text representation of the Spatial
Reference System. An example of a WKT SRS representation is:
PostGIS uses the Proj4 library to provide coordinate
transformation capabilities. The PROJ4TEXT
column contains the Proj4 coordinate definition string for
a particular SRID. For example:
For more information about, see the Proj4 web site at
http://www.remotesensing.org/proj.
The spatial_ref_sys.sql file contains
both SRTEXT and PROJ4TEXT
definitions for all EPSG projections.
The GEOMETRY_COLUMNS table definition is
as follows:
CREATE TABLE GEOMETRY_COLUMNS (
F_TABLE_CATALOG VARCHAR(256) NOT NULL,
F_TABLE_SCHEMA VARCHAR(256) NOT NULL,
F_TABLE_NAME VARCHAR(256) NOT NULL,
F_GEOMETRY_COLUMN VARCHAR(256) NOT NULL,
COORD_DIMENSION INTEGER NOT NULL,
SRID INTEGER NOT NULL,
TYPE VARCHAR(30) NOT NULL
)
The columns are as follows:
F_TABLE_CATALOG, F_TABLE_SCHEMA, F_TABLE_NAME
The fully qualified name of the feature table containing
the geometry column. Note that the terms "catalog" and
"schema" are Oracle-ish. There is not PostgreSQL analogue of
"catalog" so that column is left blank -- for "schema" the
database name is used.
F_GEOMETRY_COLUMN
The name of the geometry column in the feature
table.
COORD_DIMENSION
The spatial dimension (2 or 3 dimensional) of the
column.
SRID
The ID of the spatial reference system used for the
coordinate geometry in this table. It is a foreign key reference to the
SPATIAL_REF_SYS.
TYPE
The type of the spatial object. To restrict the spatial
column to a single type, use one of: POINT, LINESTRING,
POLYGON, MULTPOINT, MULTILINESTRING, MULTIPOLYGON,
GEOMETRYCOLLECTION. For heterogeneous (mixed-type)
collections, you can use "GEOMETRY" as the type.
Note: This attribute is (probably) not part of the OpenGIS
specification, but is required for ensuring type
homogeneity.
Creating a table with spatial data is done in two stages:
Create a normal non-spatial table.
For example: CREATE TABLE ROADS_GEOM ( ID int4, NAME
varchar(25) )
Add a spatial column to the table using the OpenGIS
"AddGeometryColumn" function. The syntax is:
AddGeometryColumn(<db_name>, <table_name>,
<column_name>, <srid>, <type>,
<dimension>).
For example: SELECT AddGeometryColumn('roads_db',
'roads_geom', 'geom', 423, 'LINESTRING', 2)
Here is an example of SQL used to create a table and add a
spatial column (assuming the db is 'parks_db' and that an SRID of 128 exists
already):
Once you have created a spatial table, you are ready to upload GIS
data to the database. Currently, there are two ways to get data into a
PostGIS/PostgreSQL database: using formatted SQL statements or using the Shape
file loader/dumper.
If you can convert your data to a text representation, then using
formatted SQL might be the easiest way to get your data into PostGIS. As with
Oracle and other SQL databases, data can be bulk loaded by piping a large text
file full of SQL "INSERT" statements into the SQL terminal monitor.
A data upload file (roads.sql for example)
might look like this:
The shp2pgsql data loader converts ESRI Shape
files into SQL suitable for insertion into a PostGIS/PostgreSQL database.
The loader has several operating modes distinguished by command line flags:
-d
Drops the database table before creating a new table with
the data in the Shape file.
-a
Appends data from the Shape file into the database table.
Note that to use this option to load multiple files, the
files must have the same attributes and same data types.
-c
Creates a new table and populates it from the Shape file.
This is the default mode.
-D
Creates a new table and populates it from the Shape file.
This uses the PostgreSQL "dump" format for the output data
and is much faster to load than the default "insert" SQL format.
Use this for very large data sets.
-s <SRID>
Creates and populates the geometry tables with the
specified SRID.
An example session using the loader to create an input file and
uploading it might look like this:
Data can be extracted from the database using either SQL or the
Shape file loader/dumper. In the section on SQL we will discuss some of the
operators available to do comparisons and queries on spatial tables.
The most straightforward means of pulling data out of the
database is to use a SQL select query and dump the resulting columns into a
parsable text file:
db=# SELECT id, AsText(geom) AS geom, name FROM ROADS_GEOM;
id | geom | name
---+-----------------------------------------+-----------
1 | LINESTRING(191232 243118,191108 243242) | Jeff Rd
2 | LINESTRING(189141 244158,189265 244817) | Geordie Rd
3 | LINESTRING(192783 228138,192612 229814) | Paul St
4 | LINESTRING(189412 252431,189631 259122) | Graeme Ave
5 | LINESTRING(190131 224148,190871 228134) | Phil Tce
6 | LINESTRING(198231 263418,198213 268322) | Dave Cres
7 | LINESTRING(218421 284121,224123 241231) | Chris Way
(6 rows)
However, there will be times when some kind of restriction is
necessary to cut down the number of fields returned. In the case of
attribute-based restrictions, just use the same SQL syntax as normal
with a non-spatial table. In the case of spatial restrictions, the
following operators are available/useful:
&&
This operator tells whether the bounding box of one
geometry overlaps the bounding box of another.
~=
This operators tests whether two geometries are
geometrically identical. For example, if 'POLYGON((0 0,1 1,1 0,0 0))'
is the same as 'POLYGON((0 0,1 1,1 0,0 0))' (it is).
=
This operator is a little more naive, it only tests whether
the bounding boxes of to geometries are the same.
Next, you can use these operators in queries. Note that when
specifying geometries and boxes on the SQL command line, you must
explicitly turn the string representations into geometries by using
the "GeometryFromText()" function. So, for example:
SELECT
ID, NAME
FROM ROADS_GEOM
WHERE
GEOM ~= GeometryFromText('LINESTRING(191232 243118,191108 243242)',-1);
The above query would return the single record from the
"ROADS_GEOM" table in which the geometry was equal to that value.
When using the "&&" operator, you can specify either a
BOX3D as the comparison feature or a GEOMETRY. When you specify a GEOMETRY,
however, its bounding box will be used for the comparison.
SELECT
ID, NAME
FROM ROADS_GEOM
WHERE
GEOM && GeometryFromText('POLYGON((191232 243117,191232 243119,191234 243117,191232 243117))',-1);
The above query will use the bounding box of the polygon for
comparison purposes.
The most common spatial query will probably be a "frame-based"
query, used by client software, like data browsers and web mappers, to
grab a "map frame" worth of data for display. Using a "BOX3D" object
for the frame, such a query looks like this:
SELECT
AsText(GEOM) AS GEOM
FROM ROADS_GEOM
WHERE
GEOM && GeometryFromText('BOX3D(191232 243117,191232 243119)'::box3d,-1);
Note the use of the SRID, to specify the projection of the BOX3D.
The value -1 is used to indicate no specified SRID.
Indexes are what make using a spatial database for large databases
possible. Without indexing, any search for a feature would require a
"sequential scan" of every record in the database. Indexing speeds up searching
by organizing the data into a search tree which can be quickly traversed to
find a particular record. PostgreSQL supports three kinds of indexes by
default: B-Tree indexes, R-Tree indexes, and GiST indexes.
B-Trees are used for data which can be sorted along one axis;
for example, numbers, letters, dates. GIS data cannot be rationally sorted
along one axis (which is greater, (0,0) or (0,1) or (1,0)?) so B-Tree indexing
is of no use for us.
R-Trees break up data into rectangles, and sub-rectangles, and
sub-sub rectangles, etc. R-Trees are used by some spatial databases to index GIS
data, but the PostgreSQL R-Tree implementation is not as robust as the GiST
implementation.
GiST (Generalized Search Trees) indexes break up data into
"things to one side", "things which overlap", "things which are inside" and can
be used on a wide range of data-types, including GIS data. PostGIS uses an
R-Tree index implemented on top of GiST to index GIS data.
GiST stands for "Generalized Search Tree" and is a generalized
form of indexing. In addition to GIS indexing, GiST is used to speed up
searches on all kinds of irregular data structures (integer arrays, spectral
data, etc) which are not amenable to normal B-Tree indexing.
Once a GIS data table exceeds a few thousand rows, you will want
to build an index to speed up spatial searches of the data (unless all your
searches are based on attributes, in which case you'll want to build a normal
index on the attribute fields).
The syntax for building a GiST index on a "geometry" column is as
follows:
CREATE INDEX [indexname] ON [tablename]
USING GIST ( [geometryfield] GIST_GEOMETRY_OPS );
Building a spatial index is a computationally intensive exercise:
on tables of around 1 million rows, on a 300MHz Solaris machine, we have found
building a GiST index takes about 1 hour. After building an index, it is
important to force PostgreSQL to collect table statistics, which are
used to optimize query plans:
VACUUM ANALYZE;
GiST indexes have two advantages over R-Tree indexes in
PostgreSQL. Firstly, GiST indexes are "null safe", meaning
they can index columns which include null values. Secondly, GiST
indexes support the concept of "lossiness" which is important
when dealing with GIS objects larger than the PostgreSQL 8K
page size. Lossiness allows PostgreSQL to store only the
"important" part of an object in an index -- in the case of GIS
objects, just the bounding box. GIS objects larger than 8K will
cause R-Tree indexes to fail in the process of being built.
Ordinarily, indexes invisibly speed up data access: once the
index is built, the query planner transparently decides when to use index
information to speed up a query plan. Unfortunately, the PostgreSQL query
planner does not optimize the use of GiST indexes well, so sometimes searches which should use a spatial index instead default to a sequence
scan of the whole table.
If you find your spatial indexes are not being used (or your
attribute indexes, for that matter) there are a couple things you can
do:
Firstly, make sure you run the "VACUUM ANALYZE [tablename]"
command on the tables you are having problems with. "VACUUM ANALYZE" gathers
statistics about the number and distributions of values in a table, to provide
the query planner with better information to make decisions around index
usage. You should regularly vacuum your databases anyways -- many PostgreSQL
DBAs have "VACUUM" run as an off-peak cron job on a regular basis.
If vacuuming does not work, you can force the planner to use the index
information by using the "SET ENABLE_SEQSCAN=OFF" command. You should only use
this command sparingly, and only on spatially indexed queries: generally
speaking, the planner knows better than you do about when to use normal B-Tree
indexes. Once you have run your query, you should consider setting
"ENABLE_SEQSCAN" back on, so that other queries will utilize the planner as
normal.
Note: As of version 0.6, it should not be necessary to force the
planner to use the index with "ENABLE_SEQSCAN".
The raison d'etre of spatial database functionality
is performing queries inside the database which would ordinarily require
desktop GIS functionality. Using PostGIS effectively requires knowing what
spatial functions are available, and ensuring that appropriate indexes are
in place to provide good performance.
When constructing a query it is important to remember that only the
bounding-box-based operators such as && can take advatage of the
GiST spatial index. Functions such as distance()
cannot use the index to optimize their operation. For example, the
following query would be quite slow on a large table:
SELECT the_geom FROM geom_table
WHERE distance( the_geom, GeometryFromText( 'POINT(100000 200000)', -1 ) ) < 100
This query is selecting all the geometries in geom_table which are within
100 units of the point (100000, 200000). It will be slow because it is
calculating the distance between each point in the table and our specified
point, ie. one distance() calculation for each row in
the table. We can avoid this by using the && operator to reduce
the number of distance calculations required:
SELECT the_geom FROM geom_table
WHERE the_geom && 'BOX3D(90900 190900, 100100 200100)'::box3d
AND distance( the_geom, GeometryFromText( 'POINT(100000 200000)', -1 ) ) < 100
This query selects the same geometries, but it does it in a more efficient way.
Assuming there is a GiST index on the_geom, the query planner will recognize that
it can use the index to reduce the number of rows before calculating the result
of the distance() function. Notice that the
BOX3D geometry which is used in the && operation is a 200 unit
square box centered on the original point - this is our "query box". The
&& operator uses the index to quickly reduce the result set down to
only those geometries which have bounding boxes that overlap the "query box".
Assuming that our query box is much smaller than the extents of the entire
geometry table, this will drastically reduce the number of distance calculations
that need to be done.
To use PostGIS with Mapserver, you will need to know about how to
configure Mapserver, which is beyond the scope of this documentation.
This section will cover specific PostGIS issues and configuration details.
To use PostGIS with Mapserver, you will need:
Version 0.6 or newer of PostGIS.
Version 3.5 or newer of Mapserver.
Mapserver accesses PostGIS/PostgreSQL data like any other
PostgreSQL client -- using libpq. This
means that Mapserver can be installed on any machine with
network access to the PostGIS server, as long as the system
has the libpq PostgreSQL client libraries.
Compile and install Mapserver, with whatever
options you desire, including the "--with-postgis"
configuration option.
In your Mapserver map file, add a PostGIS layer.
For example:
LAYER
CONNECTIONTYPE postgis
NAME "widehighways"
# Connect to a remote spatial database
CONNECTION "user=dbuser dbname=gisdatabase host=bigserver"
# Get the lines from the 'geom' column of the 'roads' table
DATA "geom from roads"
STATUS ON
TYPE LINE
# Of the lines in the extents, only render the wide highways
FILTER "type = 'highway' and numlanes >= 4"
CLASS
# Make the superhighways brighter and 2 pixels wide
EXPRESSION ([numlanes] >= 6)
COLOR 255 22 22
SYMBOL "solid"
SIZE 2
END
CLASS
# All the rest are darker and only 1 pixel wide
EXPRESSION ([numlanes] < 6)
COLOR 205 92 82
END
END
In the example above, the PostGIS-specific
directives are as follows:
CONNECTIONTYPE
For PostGIS layers, this is always
"postgis".
CONNECTION
The database connection is governed
by the a 'connection string' which is a
standard set of keys and values like this
(with the default values in <>):
An empty connection string is still valid, and
any of the key/value pairs can be omitted. At a
minimum you will generally supply the database
name and username to connect with.
DATA
The form of this parameter is "<column>
from <tablename>" where the column is the
spatial column to be rendered to the map.
FILTER
The filter must be a valid SQL string
corresponding to the logic normally following
the "WHERE" keyword in a SQL query. So, for
example, to render only roads with 6 or more lanes,
use a filter of "num_lanes >= 6".
In your spatial database, ensure you have spatial (GiST)
indexes built for any the layers you will be drawing.
CREATE INDEX [indexname]
ON [tablename]
USING GIST ( [geometrycolumn] GIST_GEOMETRY_OPS );
If you will be querying your layers using Mapserver you
will also need an "oid index".
Mapserver requires unique identifiers for each spatial
record when doing queries, and the PostGIS module of Mapserver
uses the PostgreSQL oid value to provide
these unique identifiers. A side-effect of this is that in
order to do fast random access of records during queries, an
index on the oid is needed.
The USING pseudo-SQL clause is used to add some
information to help mapserver understand the results of more complex queries.
More specifically, when either a view or a subselect is used as the source table
(the thing to the right of "FROM" in a DATA definition)
it is more difficult for mapserver to automatically determine a unique identifier
for each row and also the SRID for the table. The USING clause
can provide mapserver with these two pieces of information as follows:
DATA "the_geom FROM (SELECT table1.the_geom AS the_geom, table1.oid AS oid, table2.data AS data
FROM table1 LEFT JOIN table2 ON table1.id = table2.id) AS new_table USING UNIQUE oid USING SRID=-1"
USING UNIQUE <uniqueid>
Mapserver requires a unique id for each row in order to identify
the row when doing map queries. Normally, it would use the oid as the
unique identifier, but views and subselects don't automatically have an
oid column. If you want to use Mapserver's query functionality,
you need to add a unique column to your view or subselect, and declare
it with USING UNIQUE.
For example, you could explicitly select one of the table's oid values
for this purpose, or any other column which is guaranteed to be
unique for the result set.
The USING statement can also be useful even for simple
DATA statements, if you are doing map queries.
It was previously recommended to add an index on the oid column of tables
used in query-able layers, in order to speed up the performance of map
queries. However, with the USING clause, it is possible
to tell mapserver to use your table's primary key as the identifier for
map queries, and then it is no longer necessary to have an additional index.
Note: "Querying a Map" is the action of clicking on a map to ask for
information about the map features in that location. Don't confuse
"map queries" with the SQL query in a DATA definition.
USING SRID=<srid>
PostGIS needs to know which spatial referencing system is being used by
the geometries in order to return the correct data back to mapserver.
Normally it is possible to find this information in the "geometry_columns"
table in the PostGIS database, however, this is not possible for tables
which are created on the fly such as subselects and views.
So the USING SRID= option allows the correct SRID to be
specified in the DATA definition.
Lets start with a simple example and work our way up. Consider the following
Mapserver layer definition:
LAYER
CONNECTIONTYPE postgis
NAME "roads"
CONNECTION "user=theuser password=thepass dbname=thedb host=theserver"
DATA "the_geom FROM roads"
STATUS ON
TYPE LINE
CLASS
COLOR 0 0 0
END
END
This layer will display all the road geometries in the roads table
as black lines.
Now lets say we want to show only the highways until
we get zoomed in to at least a 1:100000 scale - the next two layers will
acheive this effect:
LAYER
CONNECTION "user=theuser password=thepass dbname=thedb host=theserver"
DATA "the_geom FROM roads"
MINSCALE 100000
STATUS ON
TYPE LINE
FILTER "road_type = 'highway'"
CLASS
COLOR 0 0 0
END
END
LAYER
CONNECTION "user=theuser password=thepass dbname=thedb host=theserver"
DATA "the_geom FROM roads"
MAXSCALE 100000
STATUS ON
TYPE LINE
CLASSITEM road_type
CLASS
EXPRESSION "highway"
SIZE 2
COLOR 255 0 0
END
CLASS
COLOR 0 0 0
END
END
The first layer is used when the scale is greater than 1:100000, and
displays only the roads of type "highway" as black lines. The
FILTER option causes only roads of type "highway" to
be displayed.
The second layer is used when the scale is less than 1:100000, and
will display highways as double-thick red lines, and other roads as
regular black lines.
So, we have done a couple of interesting things using only mapserver
functionality, but our DATA SQL statement has remained
simple. Suppose that the name of the road is stored in another table (for
whatever reason) and we need to do a join to get it and label our roads.
LAYER
CONNECTION "user=theuser password=thepass dbname=thedb host=theserver"
DATA "the_geom FROM (SELECT roads.oid AS oid, roads.the_geom AS the_geom, road_names.name as name
FROM roads LEFT JOIN road_names ON roads.road_name_id = road_names.road_name_id) AS named_roads
USING UNIQUE oid USING SRID=-1"
MAXSCALE 20000
STATUS ON
TYPE ANNOTATION
LABELITEM name
CLASS
LABEL
ANGLE auto
SIZE 8
COLOR 0 192 0
TYPE truetype
FONT arial
END
END
END
This annotation layer adds green labels to all the roads when
the scale gets down to 1:20000 or less. It also demonstrates how to
use an SQL join in a DATA definition.
Java clients can access PostGIS "geometry" objects in the
PostgreSQL database either directly as text representations or using the JDBC
extension objects bundled with PostGIS. In order to use the extension objects,
the "postgis.jar" file must be in your CLASSPATH along with the
"postgresql.jar" JDBC driver package.
import java.sql.*;
import java.util.*;
import java.lang.*;
import org.postgis.*;
public class JavaGIS {
public static void main(String[] args)
{
java.sql.Connection conn;
try
{
/*
* Load the JDBC driver and establish a connection.
*/
Class.forName("org.postgresql.Driver");
String url = "jdbc:postgresql://localhost:5432/database";
conn = DriverManager.getConnection(url, "postgres", "");
/*
* Add the geometry types to the connection. Note that you
* must cast the connection to the pgsql-specific connection * implementation before calling the addDataType() method.
*/
((org.postgresql.Connection)conn).addDataType("geometry","org.postgis.PGgeometry");
((org.postgresql.Connection)conn).addDataType("box3d","org.postgis.PGbox3d");
/*
* Create a statement and execute a select query.
*/
Statement s = conn.createStatement();
ResultSet r = s.executeQuery("select AsText(geom) as geom,id from geomtable");
while( r.next() )
{
/*
* Retrieve the geometry as an object then cast it to the geometry type.
* Print things out.
*/
PGgeometry geom = (PGgeometry)r.getObject(1);
int id = r.getInt(2);
System.out.println("Row " + id + ":");
System.out.println(geom.toString());
}
s.close();
conn.close();
}
catch( Exception e )
{
e.printStackTrace();
}
}
}
The "PGgeometry" object is a wrapper object which contains a
specific topological geometry object (subclasses of the abstract class
"Geometry") depending on the type: Point, LineString, Polygon, MultiPoint,
MultiLineString, MultiPolygon.
PGgeometry geom = (PGgeometry)r.getObject(1);
if( geom.getType() = Geometry.POLYGON )
{
Polygon pl = (Polygon)geom.getGeometry();
for( int r = 0; r < pl.numRings(); r++ )
{
LinearRing rng = pl.getRing(r);
System.out.println("Ring: " + r);
for( int p = 0; p < rng.numPoints(); p++ )
{
Point pt = rng.getPoint(p);
System.out.println("Point: " + p);
System.out.println(pt.toString());
}
}
}
The JavaDoc for the extension objects provides a reference for the
various data accessor functions in the geometric objects.
The PostGIS module is a extension to the PostgreSQL backend server.
As such, PostGIS 0.8.0 requires a full copy of the
PostgreSQL source tree in order to compile. The PostgreSQL source code
is available at
http://www.postgresql.org.
PostGIS 0.8.0 can be built against PostgreSQL versions 7.1.0 to 7.4.x.
Earlier versions of PostgreSQL are not supported.
Before you can compile the postgis server modules, you must
compile and install the PostgreSQL package.
NOTE: if you plan to use GEOS
functionality you might need to link PostgreSQL against
the standard C++ library:
LDFLAGS=-lstdc++ ./configure YOUR_OPTIONS_HERE
This is a workaround for bogus C++ exceptions interaction
with older development tools.
If you experience weird problems (backend unexpectedly
closed or similar things) try that.
# cd [postgresql source tree]/contrib
# gzip -d -c postgis-0.8.0.tar.gz | tar xvf -
Once your PostgreSQL installation is up-to-date, enter the
"postgis" directory, and edit the Makefile.
If you are compiling PostGIS 0.7.2 or earlier
against PostgreSQL 7.2.x, you must set the
USE_PG72 variable to
1. This is done automatically by
newer version of postgis.
If want support for coordinate reprojection you must
have the Proj4 library installed, set the
USE_PROJ variable to 1,
and eventually adjust PROJ_DIR to point
to your Proj4 installation directory.
If want to use GEOS functionalities you must
have the GEOS library installed, set the
USE_GEOS variable to 1,
and eventually adjust GEOS_DIR to point to
your GEOS installation directory.
Run the compile and install commands.
# make
# make install
All files are installed relative to the PostgreSQL install
directory, [prefix].
Libraries are installed
[prefix]/lib/contrib.
Important support files such as
postgis.sql are installed in
[prefix]/share/contrib.
Loader and dumber binaries are installed in
[prefix]/bin.
PostGIS requires the PL/pgSQL procedural language extension.
Before loading the postgis.sql file,
you must first enable PL/pgSQL. You should use the
createlang command. The PostgreSQL 7.1
Programmer's Guide has the details if you want to this manually
for some reason.
# createlang plpgsql [yourdatabase]
Now load the PostGIS object and function definitions into
your database by loading the postgis.sql
definitions file.
# psql -d [yourdatabase] -f postgis.sql
The PostGIS server extensions are now loaded and ready to use.
For a complete set of EPSG coordinate system definition
identifiers, you can also load the
spatial_ref_sys.sql definitions file and
populate the SPATIAL_REF_SYS table.
Upgrading PostGIS can be tricky, because the underlying C libraries
which support the object types and geometries may have changed between
versions. To avoid problems when upgrading, you will have to dump all
the tables in your database, destroy the database, create a new one,
execute the new postgis.sql file, then upload your
database dump:
Note: When upgrading from version 0.5 to 0.6+, all your geometries
will be created with an SRID of -1. To create valid OpenGIS
geometries, you will have to create a valid SRID in the
SPATIAL_REF_SYS table, and then update your geometries to
reference the SRID with the following SQL (with the appropriate
substitutions:
UPDATE TABLE <table> SET <geocolumn> = SetSRID(<geocolumn>,<SRID>);
There are several things to check when your installation or
upgrade doesn't go as you expected.
It is easiest if you untar the PostGIS
distribution into the contrib directory under the PostgreSQL
source tree. However, if this is not possible for some reason,
you can set the PGSQL_SRCenvironment
variable to the path to the PostgreSQL source directory. This
will allow you to compile PostGIS, but the
make install may not work, so be prepared
to copy the PostGIS library and executable files to the
appropriate locations yourself.
Check that you you have installed PostgreSQL 7.1 or newer,
and that you are compiling against the same version of the
PostgreSQL source as the version of PostgreSQL that is
running. Mix-ups can occur when your (Linux) distrubution has
already installed PostgreSQL, or you have otherwise installed
PostgreSQL before and forgotten about it. PostGIS will only
work with PostgreSQL 7.1 or newer, and strange, unexpected
error messages will result if you use an older version. To
check the version of PostgreSQL which is running, connect to
the database using psql and run this query:
SELECT version();
Also check that you have made any necessary changes to the top
of the Makefile. This includes:
Changing the USE_PG72=0 line to
USE_PG72=1 if you are using PostgreSQL
7.2 or newer. If this line is incorrect, it will result in
a large number of errors being generated either when compiling,
or when executing the sql statements in the postgis.sql file.
If you want to be able to do coordinate
reprojections, you must install the Proj.4 library on your
system, set the USE_PROJ variable
to 1 and the PROJ_DIR to your installation
prefix in the Makefile.
If you want to be able to use GEOS functions
you must install the GEOS library on your
system, and set the USE_GEOS to 1
and the GEOS_DIR to your installation
prefix in the Makefile.
The "&<" operator returns true if A's bounding box
overlaps or is to the left of B's bounding box.
A &> B
The "&>" operator returns true if A's bounding box
overlaps or is to the right of B's bounding box.
A << B
The "<<" operator returns true if A's bounding box is
strictly to the left of B's bounding box.
A >> B
The ">>" operator returns true if A's bounding box is
strictly to the right of B's bounding box.
A ~= B
The "~=" operator is the "same as" operator. It tests actual
geometric equality of two features. So if A and B are the same feature,
vertex-by-vertex, the operator returns true.
A @ B
The "@" operator returns true if A's bounding box is
completely contained by B's bounding box.
A ~ B
The "~" operator returns true if A's bounding box
completely contains B's bounding box.
A && B
The "&&" operator is the "overlaps" operator. If A's
bounding boux overlaps B's bounding box the operator returns true.
area2d(geometry)
Returns the area of the geometry if it is a polygon or
multi-polygon.
area(geometry)
Returns the area of the geometry if it is a polygon or
multi-polygon. (same as area2(<polygon|multipolygon>)
asbinary(geometry,'NDR')
Returns the geometry in the OGC "well-known-binary" format,
using little-endian encoding. This is useful in binary cursors to pull data out
of the database without converting it to a string representation.
isvalid(geometry)
returns true if this geometry is valid.
asbinary(geometry,'XDR')
Returns the geometry in the OGC "well-known-binary" format,
using big-endian encoding. This is useful in binary cursors to pull data out of
the database without converting it to a string representation.
GeomFromText(text,[<srid>])
Makes a Geometry from WKT with the given SRID. If SRID is not give, it defaults to -1.
OGC SPEC 3.2.6.2 - option SRID is from the conformance suite
GeometryFromText(text,[<srid>])
Makes a Geometry from WKT with the given SRID. If SRID is not give, it defaults to -1.
OGC SPEC 3.2.6.2 - option SRID is from the conformance suite
PointFromText(text,[<srid>])
Makes a Geometry from WKT with the given SRID. If SRID is not give, it defaults to -1.
OGC SPEC 3.2.6.2 - option SRID is from the conformance suite
Throws an error if the WKT is not a Point
LineFromText(text,[<srid>])
Makes a Geometry from WKT with the given SRID. If SRID is not give, it defaults to -1.
OGC SPEC 3.2.6.2 - option SRID is from the conformance suite
Throws an error if the WKT is not a Line
LinestringFromText(text,[<srid>])
Makes a Geometry from WKT with the given SRID. If SRID is not give, it defaults to -1.
from the conformance suite
Throws an error if the WKT is not a Line
PolyFromText(text,[<srid>])
Makes a Geometry from WKT with the given SRID. If SRID is not give, it defaults to -1.
OGC SPEC 3.2.6.2 - option SRID is from the conformance suite
Throws an error if the WKT is not a Polygon
PolygonFromText(text,[<srid>])
Makes a Geometry from WKT with the given SRID. If SRID is not give, it defaults to -1.
from the conformance suite
Throws an error if the WKT is not a Polygon
MPointFromText(text,[<srid>])
Makes a Geometry from WKT with the given SRID. If SRID is not give, it defaults to -1.
OGC SPEC 3.2.6.2 - option SRID is from the conformance suite
Throws an error if the WKT is not a MULTIPOINT
MLineFromText(text,[<srid>])
Makes a Geometry from WKT with the given SRID. If SRID is not give, it defaults to -1.
OGC SPEC 3.2.6.2 - option SRID is from the conformance suite
Throws an error if the WKT is not a MULTILINESTRING
MPolyFromText(text,[<srid>])
Makes a Geometry from WKT with the given SRID. If SRID is not give, it defaults to -1.
OGC SPEC 3.2.6.2 - option SRID is from the conformance suite
Throws an error if the WKT is not a MULTIPOLYGON
GeomCollFromText(text,[<srid>])
Makes a Geometry from WKT with the given SRID. If SRID is not give, it defaults to -1.
OGC SPEC 3.2.6.2 - option SRID is from the conformance suite
Throws an error if the WKT is not a GEOMETRYCOLLECTION
GeomFromWKB(text,[<srid>])
Makes a Geometry from WKB with the given SRID. If SRID is not give, it defaults to -1.
OGC SPEC 3.2.6.2 - option SRID is from the conformance suite
GeometryFromWKB(text,[<srid>])
Makes a Geometry from WKB with the given SRID. If SRID is not give, it defaults to -1.
OGC SPEC 3.2.6.2 - option SRID is from the conformance suite
PointFromWKB(text,[<srid>])
Makes a Geometry from WKB with the given SRID. If SRID is not give, it defaults to -1.
OGC SPEC 3.2.6.2 - option SRID is from the conformance suite
throws an error if WKB is not a POINT
LineFromWKB(text,[<srid>])
Makes a Geometry from WKB with the given SRID. If SRID is not give, it defaults to -1.
OGC SPEC 3.2.6.2 - option SRID is from the conformance suite
throws an error if WKB is not a LINESTRING
LinestringFromWKB(text,[<srid>])
Makes a Geometry from WKB with the given SRID. If SRID is not give, it defaults to -1.
from the conformance suite
throws an error if WKB is not a LINESTRING
PolyFromWKB(text,[<srid>])
Makes a Geometry from WKB with the given SRID. If SRID is not give, it defaults to -1.
OGC SPEC 3.2.6.2 - option SRID is from the conformance suite
throws an error if WKB is not a POLYGON
PolygonFromWKB(text,[<srid>])
Makes a Geometry from WKB with the given SRID. If SRID is not give, it defaults to -1.
from the conformance suite
throws an error if WKB is not a POLYGON
MPointFromWKB(text,[<srid>])
Makes a Geometry from WKB with the given SRID. If SRID is not give, it defaults to -1.
OGC SPEC 3.2.6.2 - option SRID is from the conformance suite
throws an error if WKB is not a MULTIPOINT
MLineFromWKB(text,[<srid>])
Makes a Geometry from WKB with the given SRID. If SRID is not give, it defaults to -1.
OGC SPEC 3.2.6.2 - option SRID is from the conformance suite
throws an error if WKB is not a MULTILINESTRING
MPolyFromWKB(text,[<srid>])
Makes a Geometry from WKB with the given SRID. If SRID is not give, it defaults to -1.
OGC SPEC 3.2.6.2 - option SRID is from the conformance suite
throws an error if WKB is not a MULTIPOLYGON
GeomCollFromWKB(text,[<srid>])
Makes a Geometry from WKB with the given SRID. If SRID is not give, it defaults to -1.
OGC SPEC 3.2.6.2 - option SRID is from the conformance suite
throws an error if WKB is not a GEOMETRYCOLLECTION
PointOnSurface(geometry)
Return a Point guaranteed to lie on the surface
Implemented using GEOS
OGC SPEC 3.2.14.2 and 3.2.18.2 -
box3d(geometry)
Returns a BOX3D representing the maximum extents of the
geometry.
collect(geometry set)
This function returns a GEOMETRYCOLLECTION object from a set
of geometries. The collect() function is an "aggregate" function in
the terminology of PostgreSQL. That means that it operators on
lists of data, in the same way the sum() and mean() functions do.
For example, "SELECT COLLECT(GEOM) FROM GEOMTABLE GROUP BY ATTRCOLUMN"
will return a separate GEOMETRYCOLLECTION for each distinct value
of ATTRCOLUMN.
mem_collect(geometry set)
This does the the same of collect(geometry), only more
memory-friendly (uses less memory and more processor time).
distance_spheroid(point, point, spheroid)
Returns linear distance between two lat/lon points given a
particular spheroid. See the explanation of spheroids given for
length_spheroid().
Currently only implemented for points.
extent(geometry set)
The extent() function is an "aggregate" function in the
terminology of PostgreSQL. That means that it operators on lists of data, in
the same way the sum() and mean() functions do. For example, "SELECT
EXTENT(GEOM) FROM GEOMTABLE" will return a BOX3D giving the maximum extend of
all features in the table. Similarly, "SELECT EXTENT(GEOM) FROM GEOMTABLE GROUP
BY CATEGORY" will return one extent result for each category.
find_srid(varchar,varchar,varchar)
The syntax is find_srid(<db/schema>, <table>, <column>) and the function returns the integer SRID of the specified column by searching through the GEOMETRY_COLUMNS table. If the geometry column has not been properly added with the AddGeometryColumns() function, this function will not work either.
force_collection(geometry)
Converts the geometry into a GEOMETRYCOLLECTION. This is
useful for simplifying the WKB representation.
Forces the geometries into a "2-dimensional mode" so that all
output representations will only have the X and Y coordinates. This is useful
for force OGC-compliant output (since OGC only specifies 2-D
geometries).
Calculates the length of of a geometry on an elipsoid. This
is useful if the coordinates of the geometry are in latitude/longitude and a
length is desired without reprojection. The elipsoid is a separate database
type and can be constructed as follows:
SELECT
length_spheroid(
geometry_column,
'SPHEROID["GRS_1980",6378137,298.257222101]'
)
FROM geometry_table;
length3d_spheroid(geometry,spheroid)
Calculates the length of of a geometry on an elipsoid, taking
the elevation into account. This is just like length_spheroid except vertical
coordinates (expressed in the same units as the spheroid axes) are used to
calculate the extra distance vertical displacement adds.
max_distance(linestring,linestring)
Returns the largest distance between two line strings.
mem_size(geometry)
Returns the amount of space (in bytes) the geometry
takes.
npoints(geometry)
Returns the number of points in the geometry.
nrings(geometry)
If the geometry is a polygon or multi-polygon returns the
number of rings.
numb_sub_objects(geometry)
Returns the number of objects stored in the geometry. This is
useful for MULTI-geometries and GEOMETRYCOLLECTIONs.
perimeter2d(geometry)
Returns the 2-dimensional perimeter of the geometry, if it is
a polygon or multi-polygon.
perimeter3d(geometry)
Returns the 3-dimensional perimeter of the geometry, if it is
a polygon or multi-polygon.
point_inside_circle(geometry,float,float,float)
The syntax for this functions is
point_inside_circle(<geometry>,<circle_center_x>,<circle_center_y>,<radius>).
Returns the true if the geometry is a point and is inside the circle. Returns
false otherwise.
postgis_version()
Returns the version number of the PostGIS functions
installed in this database.
summary(geometry)
Returns a text summary of the contents of the
geometry.
transform(geometry,integer)
Returns a new geometry with its coordinates transformed to the SRID referenced by the integer parameter. The destination SRID must exist in the SPATIAL_REF_SYS table.
translate(geometry,float8,float8,float8)
Translates the geometry to a new location using the numeric
parameters as offsets. Ie: translate(geom,X,Y,Z).
xmin(box3d) ymin(box3d) zmin(box3d)
Returns the requested minima of a bounding box.
xmax(box3d) ymax(box3d) zmax(box3d)
Returns the requested maxima of a bounding box.
simplify(geometry, tolerance)
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 isSimple)
::varchar, ::varchar)
Return the SRID number for a particular column of a database.
- AddGeometryColumn(::varchar,
::varchar,
::varchar, ::integer, ::varchar,
::integer)
Appends a geometry column to an existing table and updates the
metadata tables appropriately.
- DropGeometryColumn(::varchar,
::varchar,
::varchar)
Removes a geometry column from an existing spatial table.
- Distance(::geometry, ::geometry)
Returns the cartesian distance between two geometries.
- AsText(::geometry)
Returns the OGC well-known text version of the geometry.
- SRID(::geometry)
Returns the integer SRID of the geometry.
- GeometryFromText(::varchar, ::integer)
Creates a geometry object given the OGC well-known text and a valid
SRID.
- SetSRID(::geometry)
Sets the SRID of a geometry to a particular value.
- IsClosed(::geometry)
Returns true of first and last points of geometry are coincident.
- StartPoint(::geometry)
Returns the first point of a geometry.
- EndPoint(::geometry)
Returns the last point of a geometry.
- Centroid(::geometry)
Returns the centroid of a geometry.
- More OpenGIS SFSQL compatibility
- SPATIAL_REF_SYS table
- GEOMETRY_COLUMNS table
- SRID integrity checking
- Better Mapserver compatibility
- Minor fixes/changes
- Support for WKB in the tables
- Miscellaneous bug fixes
- Placeholders for precision grid
PostGIS 0.5
2025/07/20
- New functions
- Dimension()
- GeometryType()
- Envelope()
- X(), Y(), Z()
- NumPoints()
- PointN()
- ExteriorRing()
- NumInteriorRings()
- InteriorRingN()
- NumGeometries()
- GeometryN()
- Length_Spheroid()
- Length3D_Spheroid()
- AsBinary() + XDR and NDR variants
- force_collection()
- Removed functions
- wkb_ndr()
- wkb_xdr()
- New Objects
- SPHEROID(,,)
To be used with the length_spheroid functions for accurate
length calculations on lat/lon data.
- Minor bug fixes
- Internal Functions
- Extra constructors to make geometry manipulation easier
- Structural Reorganization
- Broke postgis.c up into four new files
postgis_debug.c -- debugging functions
postgis_fn.c -- generic functions (like length())
postgis_ops.c -- operators and indexing functions
postgis_inout.c -- type support functions and data conversion functions
PostGIS 0.2
2025/06/19
- New functions
- extent()
- force_2d()
- force_3d()
- wkb_xdr()
- wkb_ndr()
- translate()
- Fixes
- Cygwin compilation (Norman Vine)
- i386 byte alignment fixed
- 'VACUUM ANALYZE' fixed
- Other
- documentation in docbook xml
- example program for WKB access
- removed 'make test' until we can get regression
working more cleanly
PostGIS 0.1
2025/05/25
- Initial release!
- 'geometry' and 'box3d' types.
- Parsing routines for all possible geometries in OGIS text format
(POINT, LINESTRING, POLYGON, MULTIPOINT, MULTILINESTRING, MULTIPOLYGON,
GEOMETRYCOLLECTION).
- Output routines for all possible geometries in OGIS text format.
- area2d(), area3d()
- length3d(), length3d()
- perimeter2d(), perimeter3d()
- truely_inside()
- rtree index support functions
- gist index support functions
postgis-0.8.1/COPYING 0100664 0000773 0000144 00000043130 07314701322 013661 0 ustar postgis users
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
Copyright (C) 19yy
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) 19yy name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
, 1 April 2025
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Library General
Public License instead of this License.
postgis-0.8.1/CREDITS 0100664 0000773 0000144 00000002421 07760543145 013660 0 ustar postgis users CREDITS: 2025/11/24
The core team of PostGIS is from Refractions Research:
Dave Blasby, Paul Ramsey, Jeff Lounsbury and Chris Hodgson.
All versions include substantial contributions from the
core team.
VERSION SPECIFIC CREDITS:
Version 0.1 of PostGIS was developed by Refractions Research Inc, of Victora,
British Columbia, Canada (http://www.refractions.net), as a research project
into using PostgreSQL as a geospatial data-store. The following staff
participated in the project:
Dave Blasby - Core server objects and indexing (the hard stuff!)
Paul Ramsey - Extensions to the PostgreSQL JDBC driver.
Jeff Lounsbury - Shape file loader/dumper.
Version 0.2 of PostGIS includes contributions from:
Norman Vine on CygWin compilation issues
Version 0.5 of PostGIS includes contributions from:
Geographic Data BC (David Skea and Mark Sondheim) with funding and
direction on adding calculations on a spheroid to PostGIS.
Version 0.7 of PostGIS includes patches from:
Steffen Macke on numerous loader/dumper bugs.
Bernhard Reiter on some documentation issues and a loader limit.
Mark Cave-Ayland on truly_inside().
STRK on shp2pgsql improvements
Version 0.8 of PostGIS includes patches from:
Carl Anderson on schemas
STRK on numerous bug fixes and enhancements
postgis-0.8.1/Makefile 0100664 0000773 0000144 00000013331 07757177457 014321 0 ustar postgis users # Configuration Directives
#---------------------------------------------------------------
# Set USE_PROJ to 1 for Proj4 reprojection support
#
USE_PROJ=1
ifeq (${PROJ_DIR},)
PROJ_DIR=/usr/local
endif
#---------------------------------------------------------------
# Set USE_GEOS to 1 for GEOS spatial predicate and operator
# support
#
USE_GEOS=1
ifeq (${GEOS_DIR},)
GEOS_DIR=/usr/local
endif
#---------------------------------------------------------------
# Set USE_STATS to 1 for new GiST statistics collection support
# Note that this support requires additional columns in
# GEOMETRY_COLUMNS, so see the list archives for info or
# install a fresh database using postgis.sql
#
USE_STATS=1
#---------------------------------------------------------------
subdir=contrib/postgis
#---------------------------------------------------------------
# Default the root of the PostgreSQL source tree
# To use a non-standard location set the PGSQL_SRC environment
# variable to the appropriate location.
#
ifeq (${PGSQL_SRC},)
top_builddir = ../..
include $(top_builddir)/src/Makefile.global
#LPATH := $$libdir
else
top_builddir = ${PGSQL_SRC}
include $(top_builddir)/src/Makefile.global
#LPATH := ${PWD}
endif
#---------------------------------------------------------------
# Default missing CXX variable to c++
#
ifeq ($(CXX),)
CXX = c++
endif
#---------------------------------------------------------------
# Test the version string and set the USE_VERSION macro
# appropriately.
#
ifneq ($(findstring 7.1,$(VERSION)),)
USE_VERSION=71
else
ifneq ($(findstring 7.2,$(VERSION)),)
USE_VERSION=72
else
ifneq ($(findstring 7.3,$(VERSION)),)
USE_VERSION=73
else
USE_VERSION=74
endif
endif
endif
#---------------------------------------------------------------
# Shared library parameters.
#
NAME=postgis
SO_MAJOR_VERSION=0
SO_MINOR_VERSION=8
ifeq (${USE_VERSION}, 71)
MODULE_FILENAME = $(libdir)/$(shlib)
MODULE_INSTALLDIR = $(libdir)
else
MODULE_FILENAME = $$libdir/$(shlib)
MODULE_INSTALLDIR = $(pkglibdir)
endif
#---------------------------------------------------------------
override CFLAGS += -g -fexceptions
override CFLAGS += -I$(srcdir) -DFRONTEND -DSYSCONFDIR='"$(sysconfdir)"'
override CFLAGS += -DUSE_VERSION=$(USE_VERSION)
ifeq ($(USE_GEOS),1)
override CFLAGS += -I$(GEOS_DIR)/include/geos -DUSE_GEOS
endif
ifeq ($(USE_PROJ),1)
override CFLAGS += -I$(PROJ_DIR)/include -DUSE_PROJ
endif
override DLLLIBS += $(BE_DLLLIBS)
override CXXFLAGS := $(CFLAGS)
# memory debug for gcc 2.91, 2.95, 3.0 and 3.1
# for gcc >= 3.2.2 set GLIBCPP_FORCE_NEW at runtime instead
#override CXXFLAGS += -D__USE_MALLOC
#---------------------------------------------------------------
# Add index selectivity to C flags
#
ifeq ($(USE_STATS),1)
override CFLAGS += -DUSE_STATS
endif
#---------------------------------------------------------------
# Select proper GiST support C file
#
ifeq ($(USE_VERSION),71)
GIST_SUPPORT=71
GIST_ESTIMATE=
else
GIST_SUPPORT=72
GIST_ESTIMATE=postgis_estimate.o
endif
ifeq ($(USE_GEOS),1)
GEOS_WRAPPER=postgis_geos_wrapper.o
endif
OBJS=postgis_debug.o postgis_ops.o postgis_fn.o postgis_inout.o postgis_proj.o postgis_chip.o postgis_transform.o postgis_gist_$(GIST_SUPPORT).o $(GIST_ESTIMATE) postgis_geos.o $(GEOS_WRAPPER) postgis_algo.o
#---------------------------------------------------------------
# Add libraries that libpq depends (or might depend) on into the
# shared library link. (The order in which you list them here doesn't
# matter.)
SHLIB_LINK = $(filter -L%, $(LDFLAGS))
ifeq ($(USE_GEOS),1)
SHLIB_LINK += -lstdc++ -L$(GEOS_DIR)/lib -lgeos
endif
ifeq ($(USE_PROJ),1)
SHLIB_LINK += -L$(PROJ_DIR)/lib -lproj
endif
SHLIB_LINK += $(BE_DLLLIBS)
#---------------------------------------------------------------
# Makefile targets
include $(top_srcdir)/src/Makefile.shlib
postgis_geos_wrapper.o: postgis_geos_wrapper.cpp
all: all-lib postgis.sql postgis.sql postgis_undef.sql loaderdumper
loaderdumper:
$(MAKE) -C loader
# Shared library stuff
postgis.sql: postgis_sql_common.sql.in postgis_sql_$(USE_VERSION)_end.sql.in postgis_sql_$(USE_VERSION)_start.sql.in
cat postgis_sql_$(USE_VERSION)_start.sql.in postgis_sql_common.sql.in postgis_sql_$(USE_VERSION)_end.sql.in | sed -e 's:@MODULE_FILENAME@:$(MODULE_FILENAME):g;s:@POSTGIS_VERSION@:$(SO_MAJOR_VERSION).$(SO_MINOR_VERSION) USE_GEOS=$(USE_GEOS) USE_PROJ=$(USE_PROJ) USE_STATS=$(USE_STATS):g' > $@
postgis_undef.sql: postgis.sql create_undef.pl
perl create_undef.pl $< $(USE_VERSION) > $@
install: all installdirs install-postgis-lib
$(INSTALL_DATA) $(srcdir)/README.postgis $(docdir)/contrib
$(INSTALL_DATA) postgis.sql $(datadir)/contrib
$(INSTALL_DATA) postgis_undef.sql $(datadir)/contrib
$(INSTALL_DATA) spatial_ref_sys.sql $(datadir)/contrib
$(INSTALL_DATA) README.postgis $(datadir)/contrib
$(MAKE) -C loader install
#- This has been copied from postgresql and adapted
install-postgis-lib: $(shlib)
$(INSTALL_SHLIB) $< $(DESTDIR)$(MODULE_INSTALLDIR)/$(shlib)
ifneq ($(PORTNAME), win)
ifneq ($(shlib), lib$(NAME)$(DLSUFFIX).$(SO_MAJOR_VERSION))
cd $(DESTDIR)$(MODULE_INSTALLDIR) && \
rm -f lib$(NAME)$(DLSUFFIX).$(SO_MAJOR_VERSION) && \
$(LN_S) $(shlib) lib$(NAME)$(DLSUFFIX).$(SO_MAJOR_VERSION)
endif
ifneq ($(shlib), lib$(NAME)$(DLSUFFIX))
cd $(DESTDIR)$(MODULE_INSTALLDIR) && \
rm -f lib$(NAME)$(DLSUFFIX) && \
$(LN_S) $(shlib) lib$(NAME)$(DLSUFFIX)
endif
endif # not win
#----------------------------------------------------------
installdirs:
$(mkinstalldirs) $(docdir)/contrib $(datadir)/contrib $(libdir)
uninstall: uninstall-lib
@rm -f $(docdir)/contrib/README.postgis $(datadir)/contrib/postgis.sql
clean distclean maintainer-clean: clean-lib
@rm -f $(OBJS) postgis.sql postgis_undef.sql
$(MAKE) -C loader clean
$(MAKE) -C doc clean
postgis-0.8.1/README.postgis 0100664 0000773 0000144 00000014717 10000570601 015174 0 ustar postgis users PostGIS - Geographic Information Systems Extensions to PostgreSQL
~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VERSION: 0.8.1 (2025/01/12)
MORE INFORMATION: http://postgis.refractions.net
INTRODUCTION:
This distribution contains a module which implements GIS simple
features, ties the features to rtree indexing, and provides some
spatial functions for accessing and analyzing geographic data.
Directory structure:
./ Core source code, makefiles and install directions.
./jdbc Extensions to the PostgreSQL JDBC drivers to support
the GIS objects.
./doc Documentation on the code, objects and functions
provided.
./loader A program to convert ESRI Shape files into SQL text
suitable for uploading into a PostGIS/PostgreSQL database.
./examples Small programs which demonstrate ways of accessing
GIS data.
INSTALLATION:
PostGIS is compatible with PostgreSQL 7.1 and above.
To install the module, move this directory to the "contrib" directory of your
PostgreSQL source installation. Alternately, edit the "top_buildir" in the
Makefile and point it at your PostgreSQL source tree. You must have a
PostgreSQL source tree, and you must have run succesfully built and installed
it for this to work.
SEE THE NOTE ON GEOS SUPPORT BELOW FOR SPECIAL COMPILATION INSTRUCTIONS
* PROJ4 SUPPORT:
The Proj4 reprojection library is required if you want to use the
transform() function to reproject features within the database.
Install Proj4 in the default location.
Edit the postgis Makefile and change the USE_PROJ variable to 1
and ensure that the PROJ_DIR variable points to your Proj4
installation location (/usr/local is the default).
* SPATIAL PREDICATE / GEOS SUPPORT:
The GEOS library provides support for exact topological tests
such as Touches(), Contains(), Disjoint() and spatial operations
such as Intersection(), Union() and Buffer().
You can download GEOS from http://geos.refractions.net
In order to use the GEOS support, you *must* specially compile
your version of PostgreSQL to link the C++ runtime library.
To do this, invoke the PgSQL configuration script this way:
LDFLAGS=-lstdc++ ./configure --your-options-go-here
The initial LDFLAGS variable is passed through to the Makefile and
adds the C++ library to the linking stage.
Once you have compiled PgSQL with C++ support, you can enable GEOS
support in PostGIS by setting the USE_GEOS variable in the PostGIS
Makefile to 1, and ensure that the GEOS_DIR variable points to your
GEOS installation location (/usr/local is the default).
To compile PostGIS, as root run:
make
make install
PostGIS now requires the PL/pgSQL procedural language in order to operate
correctly. To install PL/pgSQL use the 'createlang' program from the PostgreSQL
installation. (The PostgreSQL Programmer's Guide has details if you want
to this manually for some reason.)
As postgres run:
createlang plpgsql yourdatabase
psql -f postgis.sql -d yourdatabase
Installation should now be complete.
UPGRADING:
Upgrading PostGIS can be tricky, because the underlying C libraries which
support the object types and geometries may have changed between versions.
To avoid problems when upgrading, you will have to dump all the tables
in your database, destroy the database, create a new one, add the PL/pgSQL
language, upload the new postgis.sql file, then upload your database dump:
pg_dump -t "*" -f dumpfile.sql yourdatabase
dropdb yourdatabase
createdb yourdatabase
createlang plpgsql yourdatabase
psql -f postgis.sql -d yourdatabase
psql -f dumpfile.sql -d yourdatabase
vacuumdb -z yourdatabase
When upgrading to 0.6+, all your geometries will be created with an SRID
of -1. To create valid OpenGIS geometries, you will have to create a
valid SRID in the SPATIAL_REF_SYS table, and then update your geometries
to reference the SRID with the following SQL (with the appropriate
substitutions:
UPDATE
SET = SetSRID(,);
USAGE:
Try the following example SQL statements to create non-OpenGIS tables and
geometries:
CREATE TABLE geom_test ( gid int4, geom geometry,name varchar(25) );
INSERT INTO geom_test ( gid, geom, name )
VALUES ( 1, 'POLYGON((0 0 0,0 5 0,5 5 0,5 0 0,0 0 0))', '3D Square');
INSERT INTO geom_test ( gid, geom, name )
VALUES ( 2, 'LINESTRING(1 1 1,5 5 5,7 7 5)', '3D Line' );
INSERT INTO geom_test ( gid, geom, name )
VALUES ( 3, 'MULTIPOINT(3 4,8 9)', '2D Aggregate Point' );
SELECT * from geom_test WHERE geom && 'BOX3D(2 2 0,3 3 0)'::box3d;
The following SQL creates proper OpenGIS entries in the SPATIAL_REF_SYS
and GEOMETRY_COLUMNS tables, and ensures that all geometries are created
with an SRID.
INSERT INTO SPATIAL_REF_SYS
( SRID, AUTH_NAME, AUTH_SRID, SRTEXT ) VALUES
( 1, 'EPSG', 4269,
'GEOGCS["NAD83",
DATUM[
"North_American_Datum_1983",
SPHEROID[
"GRS 1980",
6378137,
298.257222101
]
],
PRIMEM["Greenwich",0],
UNIT["degree",0.0174532925199433]]'
);
CREATE TABLE geotest (
id INT4,
name VARCHAR(32)
);
SELECT AddGeometryColumn('db','geotest','geopoint',1,'POINT',2);
INSERT INTO geotest (id, name, geopoint)
VALUES (1, 'Olympia', GeometryFromText('POINT(-122.90 46.97)',1));
INSERT INTO geotest (id, name, geopoint)
VALUES (2, 'Renton', GeometryFromText('POINT(-122.22 47.50)',1));
SELECT name,AsText(geopoint) FROM geotest;
Spatial Indexes:
PostgreSQL provides support for GiST spatial indexing. The GiST scheme offers
indexing even on large objects, using a system of "lossy" indexing where
a large object is proxied by a smaller one in the index. In the case
of the PostGIS indexing system, all objects are proxied in the index by
their bounding boxes.
You can build a GiST index with:
CREATE INDEX ON
USING gist ( gist_geometry_ops );
Always run the "VACUUM ANALYZE " on your tables after
creating an index. This gathers statistics which the query planner
uses to optimize index usage.
Note that PostgreSQL may occasionally not use the GiST indexes when
performing searches. If you find your system is not using the
indexes automatically (use 'EXPLAIN' to see the query plan)
you can force index use with the command:
SET ENABLE_SEQSCAN = OFF
Try doing an EXPLAIN on your query before and after the 'enable_seqscan'
command to see the different query plans.
postgis-0.8.1/TODO 0100664 0000773 0000144 00000000467 07760543145 013340 0 ustar postgis users 2003/11/20
- GML import/export routines
- Connectivity to commercial GIS software.
- Re-write WKT input/output functions to be faster
- SVG output routines
- Update PgSQL GiST to support row level (recangle level?) locking.
- Network creation and network operations
(upstream, downstream, least cost path)
postgis-0.8.1/create_undef.pl 0100664 0000773 0000144 00000005705 07714764650 015636 0 ustar postgis users # perl create_undef.pl
# creates a new sql script to delete all the postgis functions et al.
($#ARGV == 1) || die "Usage: perl create_undef.pl \nCreates a new SQL script to delete all the PostGIS functions.\n";
# drops are in the following order:
# 1. Indexing system stuff
# 2. Meta datatables
# 3. Aggregates
# 3. Casts
# 4. Operators
# 5. Functions
# 6. Types
# 7. Tables
my @aggs = ();
my @casts = ();
my @funcs = ();
my @types = ();
my @ops = ();
my $version = $ARGV[1];
print "BEGIN;\n";
if ( $version eq "73" )
{
print "-- Drop index bindings from system tables\n";
print "DROP OPERATOR CLASS gist_geometry_ops USING gist;\n";
}
else
{
print "-- Drop index bindings from system tables\n";
print "DELETE FROM pg_amproc WHERE amopclaid = (SELECT oid FROM pg_opclass WHERE opcname = 'gist_geometry_ops');\n";
print "DELETE FROM pg_amop WHERE amopclaid = (SELECT oid FROM pg_opclass WHERE opcname = 'gist_geometry_ops');\n";
print "DELETE FROM pg_opclass WHERE opcname = 'gist_geometry_ops';\n";
}
open( INPUT, $ARGV[0] ) || die "Couldn't open file: $ARGV[0]\n";
while( my $line = )
{
$line =~ s/[\r\n]//g;
push (@funcs, $line) if ($line =~ /^create function/i);
push (@ops, $line) if ($line =~ /^create operator.*\(/i);
push (@aggs, $line) if ($line =~ /^create aggregate/i);
push (@types, $line) if ($line =~ /^create type/i);
push (@casts, $line) if ($line =~ /^create cast/i);
}
close( INPUT );
print "-- Drop all aggregates.\n";
foreach my $agg (@aggs)
{
if ( $agg =~ /create aggregate\s*(\w+)\s*\(/i )
{
if ( $version eq "71" )
{
print "DROP AGGREGATE $1 geometry;\n";
}
else
{
print "DROP AGGREGATE $1 ( geometry );\n";
}
}
else
{
die "Couldn't parse line: $agg\n";
}
}
print "-- Drop all operators.\n";
foreach my $op (@ops)
{
if ($op =~ /create operator ([^(]+)/i )
{
print "DROP OPERATOR $1 (geometry,geometry);\n";
}
else
{
die "Couldn't parse line: $op\n";
}
}
print "-- Drop all casts.\n";
foreach my $cast (@casts)
{
if ($cast =~ /create cast\s*\((.+?)\)/i )
{
print "DROP CAST ($1);\n";
}
else
{
die "Couldn't parse line: $cast\n";
}
}
print "-- Drop all functions.\n";
foreach my $fn (@funcs)
{
if ($fn =~ /create function ([^(]+)\((.*)\)/i )
{
my $fn_nm = $1;
my $fn_arg = $2;
if ( $version eq "73" )
{
if ( ! ( $fn_nm =~ /_in/i || $fn_nm =~ /_out/i ) )
{
print "DROP FUNCTION $fn_nm ($fn_arg);\n";
}
}
else
{
print "DROP FUNCTION $fn_nm ($fn_arg);\n";
}
}
else
{
die "Couldn't parse line: $fn\n";
}
}
print "-- Drop all types.\n";
foreach my $type (@types)
{
if ($type =~ /create type ([^(]+)/i )
{
if ( $version eq "73" )
{
print "DROP TYPE $1 CASCADE;\n";
}
else
{
print "DROP TYPE $1;\n";
}
}
else
{
die "Couldn't parse line: $type\n";
}
}
print "-- Drop all tables.\n";
print "DROP TABLE spatial_ref_sys;\n";
print "DROP TABLE geometry_columns;\n";
print "\n";
print "COMMIT;\n";
1;
postgis-0.8.1/postgis.h 0100664 0000773 0000144 00000053661 07761626111 014511 0 ustar postgis users
/**********************************************************************
* $Id: postgis.h,v 1.39 2025/11/28 11:06:49 strk Exp $
*
* PostGIS - Spatial Types for PostgreSQL
* http://postgis.refractions.net
* Copyright 2001-2003 Refractions Research Inc.
*
* This is free software; you can redistribute and/or modify it under
* the terms of hte GNU General Public Licence. See the COPYING file.
*
**********************************************************************
* $Log: postgis.h,v $
* Revision 1.39 2025/11/28 11:06:49 strk
* Added WKB_recv function for binary WKB input
*
* Revision 1.38 2025/11/19 15:44:51 strk
* added prototypes for geometry_{le,ge,cmp}
*
* Revision 1.37 2025/10/28 16:57:35 strk
* Added collect_garray() function.
*
* Revision 1.36 2025/10/28 15:16:17 strk
* unite_sfunc() from postgis_geos.c renamed to geom_accum() and moved in postgis_fn.c
*
* Revision 1.35 2025/10/28 11:16:46 strk
* Added postgis_algo.c prototypes
*
* Revision 1.34 2025/10/16 16:35:42 dblasby
* added #include for people using freeBSD (strk@keybit.net patch)
*
* Revision 1.33 2025/08/08 18:19:20 dblasby
* Conformance changes.
* Removed junk from postgis_debug.c and added the first run of the long
* transaction locking support. (this will change - dont use it)
* conformance tests were corrected
* some dos cr/lf removed
* empty geometries i.e. GEOMETRYCOLLECT(EMPTY) added (with indexing support)
* pointN(,1) now returns the first point (used to return 2nd)
*
* Revision 1.32 2025/08/06 19:31:18 dblasby
* Added the WKB parser. Added all the functions like
* PolyFromWKB(,[]).
*
* Added all the functions like PolyFromText(,[])
*
* Minor problem in GEOS library fixed.
*
* Revision 1.31 2025/07/25 17:08:37 pramsey
* Moved Cygwin endian define out of source files into postgis.h common
* header file.
*
* Revision 1.30 2025/07/01 18:30:55 pramsey
* Added CVS revision headers.
*
*
**********************************************************************/
/*
* Everything is stored in a geometry3d, which is just a conglomeration
* of the base types (and a little bit of other info).
*/
#include
#include "utils/geo_decls.h"
#define POINTTYPE 1
#define LINETYPE 2
#define POLYGONTYPE 3
#define MULTIPOINTTYPE 4
#define MULTILINETYPE 5
#define MULTIPOLYGONTYPE 6
#define COLLECTIONTYPE 7
#define BBOXONLYTYPE 99
/*
* Norman Vine found this problem for compiling under cygwin
* it defines BYTE_ORDER and LITTLE_ENDIAN
*/
#ifdef __CYGWIN__
#include // FOR ENDIAN DEFINES
#endif
//standard definition of an ellipsoid (what wkt calls a spheroid)
// f = (a-b)/a
// e_sq = (a*a - b*b)/(a*a)
// b = a - fa
typedef struct
{
double a; //semimajor axis
double b; //semiminor axis
double f; //flattening
double e; //eccentricity (first)
double e_sq; //eccentricity (first), squared
char name[20]; //name of ellipse
} SPHEROID;
/*---------------------------------------------------------------------
* POINT3D - (x,y,z)
* Base type for all geometries
* Also used for POINT type and MULTIPOINT type
*-------------------------------------------------------------------*/
typedef struct
{
double x,y,z; //for lat/long x=long, y=lat
} POINT3D;
/*---------------------------------------------------------------------
* BOX3D - Specified by two corner points, which are
* sorted to save calculation time later.
*
* LLB -- lower right bottom point (ie. South West, Z low)
* URT -- upper right top point (ie. North East, Z high)
*
* this is the long diagonal
*
* example:
* BOX([0.0,0.0,0.0],[10.0,10.0,10.0])
*
* NOTE: You CAN make columns in your database of this type
* IT IS NOT A TRUE GEOMETRY!
*-------------------------------------------------------------------*/
typedef struct
{
POINT3D LLB,URT; /* corner POINT3Ds on long diagonal */
} BOX3D;
/*---------------------------------------------------------------------
* LINE - set of points (directed arcs)
* P1->P2->P3->P4...->Pn
*-------------------------------------------------------------------*/
typedef struct
{
int32 npoints; // how many points in the line
int32 junk; // double-word alignment
POINT3D points[1]; // array of actual points
} LINE3D;
/*---------------------------------------------------------------------
* POLYGON - set of closed rings. First ring in outer boundary
* other rings are "holes"
*
* NOTE: this is acually stored a bit differently. It is more like:
* int32 nrings
* char filler[]
*
* where the 1st 4 byes of filler[] is npoints[0] the next 4 bytes
* are npoints[1], etc...
*
* points[0] is either at filler[ 4 * nrings]
* or at filler [ 4* nrings + 4]
* Which ever one is double-word-aligned
*-------------------------------------------------------------------*/
typedef struct
{
int32 nrings; // how many rings in this polygon
int32 npoints[1]; //how many points in each ring
/* could be 4 byes of filler here to make sure points[] is
double-word aligned*/
POINT3D points[1]; // array of actual points
} POLYGON3D;
/*---------------------------------------------------------------------
* Geometry - all columns in postgres are of this type
*
* Geometries are collections of simple geometry types
* (point, line, polygon).
*
* A Point is a geometry with a single point in it.
* A MultiPoint is a geometry with a list of 'point' in it.
* A Line is a geometry with a single line in it.
* A MultiLine is a geometry with a list of 'line' in it.
* A Polygon is a geometry with a single polygon in it.
* A MultiPolygon is a geometry with a list of 'polygon' in it.
* A Collection is a geometry with a (mixed) list of
* point, line, and polygon.
*
* The bvol is the bounding volume of all the subobjects.
*
* is3d is true if the original data was sent in a 3d data.
* 2d data is 3d data with z=0.0.
*
* 'type' has values:
* Point -> POINTTYPE
* MultiPoint -> MULTIPOINTTYPE
* Line -> LINETYPE
* MultiLine -> MULTILINETYPE
* Polygon -> POLYGONTYPE
* MultiPolygon -> MULTIPOLYGONTYPE
* Collection -> COLLECTIOMTYPE
*
* 'objType' has values:
* Point -> POINTTYPE
* Line -> LINETYPE
* Polygon -> POLYGONTYPE
*
* 'objOffset' is an offset (in bytes) into this structure of where
* the subobject is defined. THESE ARE ALWAYS DOUBLE-WORD ALIGNED.
*
*
* In reality the structure looks like:
* int32 size;
* int32 type;
* bool is3d;
*
* BOX3D bvol;
* int32 nobjs;
* char data[...];
*
* AND:
* &objType[0] = &data[0]
* &objType[1] = &data[4]
* ...
* &obgOffset[0] = &data[ 4* nobjs]
* &obgOffset[1] = &data[ 4* nobjs + 4]
* ...
* &objData[0] = &GEOMETRY + objOffset[0] //always double-word aligned
* &objData[1] = &GEOMETRY + objOffset[1] //always double-word aligned
* ...
*
* ALL GEOMETRY COLUMNS IN YOUR DATABASE SHOULD BE OF THIS TYPE
*-------------------------------------------------------------------*/
typedef struct
{
int32 size; // postgres variable-length type requirement
int32 SRID; // spatial reference system id
double offsetX; // for precision grid (future improvement)
double offsetY; // for precision grid (future improvement)
double scale; // for precision grid (future improvement)
int32 type; // this type of geometry
bool is3d; // true if the points are 3d (only for output)
BOX3D bvol; // bounding volume of all the geo objects
int32 nobjs; // how many sub-objects in this object
int32 objType[1]; // type of object
int32 objOffset[1];// offset (in bytes) into this structure where
// the object is located
char objData[1]; // store for actual objects
} GEOMETRY;
typedef struct chiptag
{
int size; //unused (for use by postgresql)
int endian_hint; // the number 1 in the endian of this datastruct
BOX3D bvol;
int SRID;
char future[4];
float factor; //usually 1.0. Integer values are multiplied by this number
//to get the actual height value (for sub-meter accuracy
//height data).
int datatype; // 1 = float32, 5 = 24bit integer, 6 = 16bit integer (short)
// 101 = float32 (NDR), 105 = 24bit integer (NDR), 106=16bit int (NDR)
int height;
int width;
int compression; //# 0 = no compression, 1 = differencer
// 0x80 = new value
// 0x7F = nodata
// this is provided for convenience, it should be set to
// sizeof(chip) bytes into the struct because the serialized form is:
//
// NULL when serialized
void *data; // data[0] = bottm left, data[width] = 1st pixel, 2nd row (uncompressed)
} CHIP;
//for GiST indexing
//This is the BOX type from geo_decls.h
// Its included here for the GiST index.
// Originally, we used BOXONLYTYPE geometries as our keys, but after
// Oleg and teodor (http://www.sai.msu.su/~megera/postgres/gist/)
// have released a more generic rtree/gist index for geo_decls.h polygon
// type. I am using a slightly modified version of this, so
// it will be easier to maintain.
//
// Their indexing is based on the BOX object, so we include it here.
// ONLY FOR INDEXING
typedef struct geomkey {
int32 size; /* size in varlena terms */
BOX key;
int32 SRID; //spatial reference system identifier
} GEOMETRYKEY;
// WKB structure -- exactly the same as TEXT
typedef struct Well_known_bin {
int32 size; // total size of this structure
unsigned char data[1]; //THIS HOLD VARIABLE LENGTH DATA
} WellKnownBinary;
// --------------------------------------------
// histogram2d type
// 2d histogram is a bounding box with a bunch of cells in it.
// The cells will have width (xmax-xmin)/boxesPerSide
// and height(ymax-ymin)/boxesPerSide
// The first box is the ll corner's box, the send is directly to the right
// (row-major).
//
// Size of structure is:
// 4 (size) + 32 (box) + 4 (boxesPerSide) +
// boxesPerSide*boxesPerSide*4 (data)
typedef struct histotag
{
int32 size; // postgres variable-length type requirement
int boxesPerSide; //boxesPerSide * boxesPerSide = total boxes in grid
double avgFeatureArea; // average bbox area of features in this histogram
// double will be correctly aligned
double xmin,ymin, xmax, ymax; // BOX of area
unsigned int value[1]; // variable length # of ints for histogram
} HISTOGRAM2D;
//prototypes
int isspace(int c);
/* constructors*/
POLYGON3D *make_polygon(int nrings, int *pts_per_ring, POINT3D *pts, int npoints, int *size);
void set_point( POINT3D *pt,double x, double y, double z);
GEOMETRY *make_oneobj_geometry(int sub_obj_size, char *sub_obj, int type, bool is3d, int SRID,double scale, double offx,double offy);
void print_point(char *result, POINT3D *pt,bool is3d);
void print_many_points(char *result, POINT3D *pt ,int npoints, bool is3d);
void swap(double *d1, double *d2);
int numb_points_in_list(char *str);
bool parse_points_in_list(char *str, POINT3D *points, int32 max_points, bool *is3d);
bool parse_points_in_list_exact(char *str, POINT3D *points, int32 max_points, bool *is3d);
int find_outer_list_length(char *str);
bool points_per_sublist( char *str, int32 *npoints, int32 max_lists);
char *scan_to_same_level(char *str);
int objects_inside_point(char *str);
int objects_inside_line(char *str);
int objects_inside_polygon(char *str);
int objects_inside_multipoint(char *str);
int objects_inside_multiline(char *str);
int objects_inside_multipolygon(char *str);
int objects_inside_collection(char *str);
int objects_inside(char *str);
bool parse_objects_inside_point(int32 *obj_size,char **objs, int32 *obj_types, int32 nobjs, char *str, int *offset, bool* is3d);
bool parse_objects_inside_multipoint(int32 *obj_size,char **objs, int32 *obj_types, int32 nobjs, char *str, int *offset, bool* is3d);
bool parse_objects_inside_line(int32 *obj_size,char **objs, int32 *obj_types, int32 nobjs, char *str, int *offset, bool* is3d);
bool parse_objects_inside_multiline(int32 *obj_size,char **objs, int32 *obj_types, int32 nobjs, char *str, int *offset, bool* is3d);
bool parse_objects_inside_polygon(int32 *obj_size,char **objs, int32 *obj_types, int32 nobjs, char *str, int *offset, bool* is3d);
bool parse_objects_inside_multipolygon(int32 *obj_size,char **objs, int32 *obj_types, int32 nobjs, char *str, int *offset, bool* is3d);
bool parse_objects(int32 *obj_size,char **objs,int32 *obj_types,int32 nobjs,char *str, int *offset, bool *is3d);
bool parse_objects_inside_collection(int32 *obj_size,char **objs, int32 *obj_types, int32 nobjs, char *str, int *offset, bool* is3d);
BOX3D *bbox_of_point(POINT3D *pt);
BOX3D *bbox_of_polygon(POLYGON3D *polygon);
BOX3D *bbox_of_line(LINE3D *line);
BOX3D *union_box3d(BOX3D *a, BOX3D *b);
BOX3D *bbox_of_geometry(GEOMETRY *geom);
GEOMETRY *make_bvol_geometry(BOX3D *box);
bool box3d_ov(BOX3D *box1, BOX3D *box2);
bool is_same_point(POINT3D *p1, POINT3D *p2);
bool is_same_line(LINE3D *l1, LINE3D *l2);
bool is_same_polygon(POLYGON3D *poly1, POLYGON3D *poly2);
BOX *convert_box3d_to_box(BOX3D *in);
double line_length2d(LINE3D *line);
double line_length3d(LINE3D *line);
double polygon_area2d_old(POLYGON3D *poly1);
double polygon_perimeter3d(POLYGON3D *poly1);
double polygon_perimeter2d(POLYGON3D *poly1);
int PIP( POINT3D *P, POINT3D *V, int n );
bool point_truely_inside(POINT3D *point, BOX3D *box);
int compute_outcode( POINT3D *p, BOX3D *box);
bool lineseg_inside_box( POINT3D *P1, POINT3D *P2, BOX3D *box);
bool linestring_inside_box(POINT3D *pts, int npoints, BOX3D *box);
bool polygon_truely_inside(POLYGON3D *poly, BOX3D *box);
bool line_truely_inside( LINE3D *line, BOX3D *box);
void translate_points(POINT3D *pt, int npoints,double x_off, double y_off, double z_off);
int size_subobject (char *sub_obj, int type);
GEOMETRY *add_to_geometry(GEOMETRY *geom,int sub_obj_size, char *sub_obj, int type);
LINE3D *make_line(int npoints, POINT3D *pts, int *size);
void swap_char(char *a, char*b);
void flip_endian_double(char *dd);
void flip_endian_int32(char *ii);
char *to_wkb(GEOMETRY *geom, bool flip_endian);
char *wkb_multipolygon(POLYGON3D **polys,int numb_polys,int32 *size, bool flipbytes, char byte_order,bool use3d);
char *wkb_polygon(POLYGON3D *poly,int32 *size, bool flipbytes, char byte_order,bool use3d, char *mem);
char *wkb_multiline(LINE3D **lines,int32 *size, int numb_lines, bool flipbytes, char byte_order,bool use3d);
char *wkb_line(LINE3D *line,int32 *size, bool flipbytes, char byte_order,bool use3d, char *mem);
char *wkb_point(POINT3D *pt,int32 *size, bool flipbytes, char byte_order, bool use3d);
char *wkb_multipoint(POINT3D *pt,int32 numb_points,int32 *size, bool flipbytes, char byte_order,bool use3d);
char *to_wkb_collection(GEOMETRY *geom, bool flip_endian, int32 *size);
char *to_wkb_sub(GEOMETRY *geom, bool flip_endian, int32 *wkb_size);
double deltaLongitude(double azimuth, double sigma, double tsm,SPHEROID *sphere);
double bigA(double u2);
double bigB(double u2);
double distance_ellipse(double lat1, double long1,
double lat2, double long2,
SPHEROID *sphere);
double mu2(double azimuth,SPHEROID *sphere);
double length2d_ellipse_linestring(LINE3D *line, SPHEROID *sphere);
double length3d_ellipse_linestring(LINE3D *line, SPHEROID *sphere);
double distance_pt_pt(POINT3D *p1, POINT3D *p2);
double distance_pt_line(POINT3D *p1, LINE3D *l2);
double distance_pt_poly(POINT3D *p1, POLYGON3D *poly2);
double distance_line_line(LINE3D *l1, LINE3D *l2);
double distance_line_poly(LINE3D *l1, POLYGON3D *poly2);
double distance_poly_poly(POLYGON3D *poly1, POLYGON3D *poly2);
double distance_pt_seg(POINT3D *p, POINT3D *A, POINT3D *B);
double distance_seg_seg(POINT3D *A, POINT3D *B, POINT3D *C, POINT3D *D);
bool point_in_poly(POINT3D *p, POLYGON3D *poly);
POINT3D *segmentize_ring(POINT3D *points, double dist, int num_points_in, int *num_points_out);
Datum optimistic_overlap(PG_FUNCTION_ARGS);
unsigned char parse_hex(char *str);
void deparse_hex(unsigned char str, unsigned char *result);
char *geometry_to_text(GEOMETRY *geometry);
BOX3D *parse_box3d(char *str);
int getint(char *c);
double getdouble(char *c);
GEOMETRY *WKBtoGeometry(char *WKB, int length, int *bytes_read);
POINT3D *wkb_linearring(char *WKB,char is3d, char flip_endian, int *numbPoints, int *bytes,int bytes_in_stream);
GEOMETRY *makeNullGeometry(int SRID);
void compressType(GEOMETRY *g);
void DP_findsplit(POINT3D *, int, int, int, int *, double *);
void DP_simplify(POINT3D *, int, POINT3D **, int *, double);
char *simplify_line3d(LINE3D *, double);
char *simplify_polygon3d(POLYGON3D *, double);
char *simplify_point3d(POINT3D *, double);
//exposed to psql
Datum box3d_in(PG_FUNCTION_ARGS);
Datum box3d_out(PG_FUNCTION_ARGS);
Datum geometry_in(PG_FUNCTION_ARGS);
Datum geometry_out(PG_FUNCTION_ARGS);
Datum astext_geometry(PG_FUNCTION_ARGS);
Datum geometry_text(PG_FUNCTION_ARGS);
Datum get_bbox_of_geometry(PG_FUNCTION_ARGS);
Datum get_geometry_of_bbox(PG_FUNCTION_ARGS);
Datum box3d_same(PG_FUNCTION_ARGS);
Datum geometry_overleft(PG_FUNCTION_ARGS);
Datum geometry_left(PG_FUNCTION_ARGS);
Datum geometry_right(PG_FUNCTION_ARGS);
Datum geometry_overright(PG_FUNCTION_ARGS);
Datum geometry_contained(PG_FUNCTION_ARGS);
Datum geometry_contain(PG_FUNCTION_ARGS);
Datum geometry_overlap(PG_FUNCTION_ARGS);
Datum geometry_same(PG_FUNCTION_ARGS);
Datum box3d_overlap(PG_FUNCTION_ARGS);
Datum box3d_overleft(PG_FUNCTION_ARGS);
Datum box3d_right(PG_FUNCTION_ARGS);
Datum box3d_contain(PG_FUNCTION_ARGS);
Datum geometry_union(PG_FUNCTION_ARGS);
Datum geometry_inter(PG_FUNCTION_ARGS);
Datum geometry_size(PG_FUNCTION_ARGS);
Datum length3d(PG_FUNCTION_ARGS);
Datum length2d(PG_FUNCTION_ARGS);
Datum area2d(PG_FUNCTION_ARGS);
Datum perimeter3d(PG_FUNCTION_ARGS);
Datum perimeter2d(PG_FUNCTION_ARGS);
Datum truly_inside(PG_FUNCTION_ARGS);
Datum geometry_lt(PG_FUNCTION_ARGS);
Datum geometry_le(PG_FUNCTION_ARGS);
Datum geometry_eq(PG_FUNCTION_ARGS);
Datum geometry_gt(PG_FUNCTION_ARGS);
Datum geometry_ge(PG_FUNCTION_ARGS);
Datum geometry_cmp(PG_FUNCTION_ARGS);
Datum npoints(PG_FUNCTION_ARGS);
Datum nrings(PG_FUNCTION_ARGS);
Datum mem_size(PG_FUNCTION_ARGS);
Datum summary(PG_FUNCTION_ARGS);
Datum translate(PG_FUNCTION_ARGS);
Datum asbinary_specify(PG_FUNCTION_ARGS);
Datum asbinary_simple(PG_FUNCTION_ARGS);
Datum force_2d(PG_FUNCTION_ARGS);
Datum force_3d(PG_FUNCTION_ARGS);
Datum force_collection(PG_FUNCTION_ARGS);
Datum combine_bbox(PG_FUNCTION_ARGS);
Datum dimension(PG_FUNCTION_ARGS);
Datum geometrytype(PG_FUNCTION_ARGS);
Datum envelope(PG_FUNCTION_ARGS);
Datum x_point(PG_FUNCTION_ARGS);
Datum y_point(PG_FUNCTION_ARGS);
Datum z_point(PG_FUNCTION_ARGS);
Datum numpoints_linestring(PG_FUNCTION_ARGS);
Datum pointn_linestring(PG_FUNCTION_ARGS);
Datum exteriorring_polygon(PG_FUNCTION_ARGS);
Datum numinteriorrings_polygon(PG_FUNCTION_ARGS);
Datum interiorringn_polygon(PG_FUNCTION_ARGS);
Datum numgeometries_collection(PG_FUNCTION_ARGS);
Datum geometryn_collection(PG_FUNCTION_ARGS);
Datum ellipsoid_out(PG_FUNCTION_ARGS);
Datum ellipsoid_in(PG_FUNCTION_ARGS);
Datum length_ellipsoid(PG_FUNCTION_ARGS);
Datum length3d_ellipsoid(PG_FUNCTION_ARGS);
Datum distance_ellipsoid(PG_FUNCTION_ARGS);
Datum point_inside_circle(PG_FUNCTION_ARGS);
Datum distance(PG_FUNCTION_ARGS);
Datum expand_bbox(PG_FUNCTION_ARGS);
Datum srid_geom(PG_FUNCTION_ARGS);
Datum geometry_from_text(PG_FUNCTION_ARGS);
Datum startpoint(PG_FUNCTION_ARGS);
Datum endpoint(PG_FUNCTION_ARGS);
Datum isclosed(PG_FUNCTION_ARGS);
Datum centroid(PG_FUNCTION_ARGS);
Datum postgis_gist_sel(PG_FUNCTION_ARGS);
Datum WKB_in(PG_FUNCTION_ARGS);
Datum WKB_out(PG_FUNCTION_ARGS);
Datum WKB_recv(PG_FUNCTION_ARGS);
Datum CHIP_in(PG_FUNCTION_ARGS);
Datum CHIP_out(PG_FUNCTION_ARGS);
Datum CHIP_to_geom(PG_FUNCTION_ARGS);
Datum srid_chip(PG_FUNCTION_ARGS);
Datum setsrid_chip(PG_FUNCTION_ARGS);
Datum width_chip(PG_FUNCTION_ARGS);
Datum height_chip(PG_FUNCTION_ARGS);
Datum datatype_chip(PG_FUNCTION_ARGS);
Datum compression_chip(PG_FUNCTION_ARGS);
Datum setfactor_chip(PG_FUNCTION_ARGS);
Datum factor_chip(PG_FUNCTION_ARGS);
Datum segmentize(PG_FUNCTION_ARGS);
Datum box3d_xmin(PG_FUNCTION_ARGS);
Datum box3d_ymin(PG_FUNCTION_ARGS);
Datum box3d_zmin(PG_FUNCTION_ARGS);
Datum box3d_xmax(PG_FUNCTION_ARGS);
Datum box3d_ymax(PG_FUNCTION_ARGS);
Datum box3d_zmax(PG_FUNCTION_ARGS);
Datum box3dtobox(PG_FUNCTION_ARGS);
Datum transform_geom(PG_FUNCTION_ARGS);
Datum max_distance(PG_FUNCTION_ARGS);
Datum geom_accum(PG_FUNCTION_ARGS);
Datum collect_garray(PG_FUNCTION_ARGS);
Datum collector(PG_FUNCTION_ARGS);
Datum WKBtoBYTEA(PG_FUNCTION_ARGS);
Datum histogram2d_in(PG_FUNCTION_ARGS);
Datum histogram2d_out(PG_FUNCTION_ARGS);
Datum create_histogram2d(PG_FUNCTION_ARGS);
Datum build_histogram2d(PG_FUNCTION_ARGS);
Datum geometry2box(PG_FUNCTION_ARGS);
Datum explode_histogram2d(PG_FUNCTION_ARGS);
Datum estimate_histogram2d(PG_FUNCTION_ARGS);
Datum postgisgistcostestimate(PG_FUNCTION_ARGS);
Datum geometryfromWKB(PG_FUNCTION_ARGS);
Datum geometryfromWKB_SRID(PG_FUNCTION_ARGS);
Datum PointfromWKB_SRID(PG_FUNCTION_ARGS);
Datum LinefromWKB_SRID(PG_FUNCTION_ARGS);
Datum PolyfromWKB_SRID(PG_FUNCTION_ARGS);
Datum MPointfromWKB_SRID(PG_FUNCTION_ARGS);
Datum MLinefromWKB_SRID(PG_FUNCTION_ARGS);
Datum MPolyfromWKB_SRID(PG_FUNCTION_ARGS);
Datum GCfromWKB_SRID(PG_FUNCTION_ARGS);
Datum geometry_from_text_poly(PG_FUNCTION_ARGS);
Datum geometry_from_text_mpoly(PG_FUNCTION_ARGS);
Datum geometry_from_text_point(PG_FUNCTION_ARGS);
Datum geometry_from_text_mpoint(PG_FUNCTION_ARGS);
Datum geometry_from_text_line(PG_FUNCTION_ARGS);
Datum geometry_from_text_mline(PG_FUNCTION_ARGS);
Datum geometry_from_text_gc(PG_FUNCTION_ARGS);
Datum isempty(PG_FUNCTION_ARGS);
Datum simplify(PG_FUNCTION_ARGS);
/*--------------------------------------------------------------------
* Useful floating point utilities and constants.
* from postgres geo_decls.c
* EPSILON modified to be more "double" friendly
*-------------------------------------------------------------------*/
// from contrib/cube/cube.c
#define max(a,b) ((a) > (b) ? (a) : (b))
#define min(a,b) ((a) <= (b) ? (a) : (b))
#define abs(a) ((a) < (0) ? (-a) : (a))
postgis-0.8.1/postgis_algo.c 0100664 0000773 0000144 00000023637 07747170633 015515 0 ustar postgis users /**********************************************************************
* $Id: postgis_algo.c,v 1.1 2025/10/27 10:21:15 strk Exp $
*
* PostGIS - Spatial Types for PostgreSQL
* http://postgis.refractions.net
* Copyright 2001-2003 Refractions Research Inc.
*
* This is free software; you can redistribute and/or modify it under
* the terms of the GNU General Public Licence. See the COPYING file.
*
**********************************************************************
* $Log: postgis_algo.c,v $
* Revision 1.1 2025/10/27 10:21:15 strk
* Initial import.
*
**********************************************************************/
#include "postgres.h"
#include "postgis.h"
/***********************************************************************
* Simple Douglas-Peucker line simplification.
* No checks are done to avoid introduction of self-intersections.
* No topology relations are considered.
*
* --strk@keybit.net;
***********************************************************************/
#define SAMEPOINT(a,b) ((a)->x==(b)->x&&(a)->y==(b)->y&&(a)->z==(b)->z)
#define VERBOSE 0
#if VERBOSE > 0
#undef REPORT_POINTS_REDUCTION
#undef REPORT_RINGS_REDUCTION
#define REPORT_RINGS_ADJUSTMENTS
#endif
#undef CHECK_RING_IS_CLOSE
/*
* Search farthest point from segment p1-p2
* returns squared distance an int pointer
*/
void DP_findsplit(POINT3D *pts, int npts, int p1, int p2,
int *split, double *dist)
{
int k;
POINT3D *pa, *pb, *pk;
double tmp;
#if VERBOSE > 4
elog(NOTICE, "DP_findsplit called");
#endif
*dist = -1;
*split = p1;
if (p1 + 1 < p2)
{
pa = &(pts[p1]);
pb = &(pts[p2]);
#if VERBOSE > 4
elog(NOTICE, "DP_findsplit: P%d(%f,%f) to P%d(%f,%f)",
p1, pa->x, pa->y, p2, pb->x, pb->y);
#endif
for (k=p1+1; k 4
elog(NOTICE, "DP_findsplit: P%d(%f,%f)", k, pk->x, pk->y);
#endif
/* distance computation */
tmp = distance_pt_seg(pk, pa, pb);
if (tmp > *dist)
{
*dist = tmp; /* record the maximum */
*split = k;
#if VERBOSE > 4
elog(NOTICE, "DP_findsplit: P%d is farthest (%g)", k, *dist);
#endif
}
}
} /* length---should be redone if can == 0 */
else
{
#if VERBOSE > 3
elog(NOTICE, "DP_findsplit: segment too short, no split/no dist");
#endif
}
}
void
DP_simplify(POINT3D *inpts, int inptsn, POINT3D **outpts, int *outptsn, double epsilon)
{
int stack[inptsn]; /* recursion stack */
int sp=-1; /* recursion stack pointer */
int p1, split;
double dist_sq;
double epsilon_sq = epsilon*epsilon;
POINT3D *outpoints;
int numoutpoints=0;
p1 = 0;
stack[++sp] = inptsn-1;
#if VERBOSE > 4
elog(NOTICE, "DP_simplify called");
#endif
outpoints = (POINT3D *)palloc( sizeof(POINT3D) * inptsn);
memcpy(outpoints, inpts, sizeof(POINT3D));
numoutpoints++;
#if VERBOSE > 3
elog(NOTICE, "DP_simplify: added P0 to simplified point array (size 1)");
#endif
do
{
DP_findsplit(inpts, inptsn, p1, stack[sp], &split, &dist_sq);
#if VERBOSE > 3
elog(NOTICE, "DP_simplify: farthest point from P%d-P%d is P%d (dist. %g)", p1, stack[sp], split, sqrt(dist_sq));
#endif
if (dist_sq > epsilon_sq) {
stack[++sp] = split;
} else {
/*
outpoints = repalloc( outpoints, sizeof(POINT3D) * numoutpoints+1 );
if ( outpoints == NULL ) elog(NOTICE, "Out of virtual memory");
*/
memcpy(outpoints+numoutpoints, &(inpts[stack[sp]]),
sizeof(POINT3D));
numoutpoints++;
#if VERBOSE > 3
elog(NOTICE, "DP_simplify: added P%d to simplified point array (size: %d)",
stack[sp], numoutpoints);
#endif
p1 = stack[sp--];
}
#if VERBOSE > 5
elog(NOTICE, "stack pointer = %d", sp);
#endif
}
while (! (sp<0) );
/*
* If we have reduced the number of points realloc
* outpoints array to free up some memory.
* Might be turned on and of with a SAVE_MEMORY define ...
*/
if ( numoutpoints < inptsn )
{
outpoints = (POINT3D *)repalloc(outpoints, sizeof(POINT3D)*numoutpoints);
if ( outpoints == NULL ) {
elog(ERROR, "Out of virtual memory");
}
}
*outpts = outpoints;
*outptsn = numoutpoints;
}
char *
simplify_line3d(LINE3D *iline, double dist)
{
POINT3D *ipts;
POINT3D *opts;
int iptsn, optsn, olinesize;
LINE3D *oline;
ipts = iline->points;
iptsn = iline->npoints;
DP_simplify(ipts, iptsn, &opts, &optsn, dist);
oline = make_line(optsn, opts, &olinesize);
return (char *)oline;
}
char *
simplify_polygon3d(POLYGON3D *ipoly, double dist)
{
POINT3D *ipts;
POINT3D *opts;
int iptsn, optsn, size;
int nrings;
int pts_per_ring[ipoly->nrings];
POLYGON3D *opoly;
int ri;
POINT3D *allpts = NULL;
int allptsn = 0;
int pt_off = 0; /* point offset for each ring */
nrings = 0;
#ifdef REPORT_RINGS_REDUCTION
elog(NOTICE, "simplify_polygon3d: simplifying polygon with %d rings",
ipoly->nrings);
#endif
/* Points start here */
ipts = (POINT3D *) ((char *)&(ipoly->npoints[ipoly->nrings] ));
pt_off=0;
for (ri=0; rinrings; pt_off += ipoly->npoints[ri++])
{
iptsn = ipoly->npoints[ri];
#ifdef CHECK_RING_IS_CLOSE
if ( ! SAMEPOINT(ipts+pt_off, ipts+pt_off+iptsn-1) )
elog(NOTICE, "First point != Last point");
#endif
DP_simplify(ipts+pt_off, iptsn, &opts, &optsn, dist);
if ( optsn < 2 )
{
/* There as to be an error in DP_simplify */
elog(NOTICE, "DP_simplify returned a <2 pts array");
pfree(opts);
continue;
}
#ifdef CHECK_RING_IS_CLOSE
if ( ! SAMEPOINT(opts, opts+optsn-1) )
elog(NOTICE, "First point != Last point");
#endif
if ( optsn < 4 )
{
pfree(opts);
#ifdef REPORT_RINGS_ADJUSTMENTS
elog(NOTICE, "simplify_polygon3d: ring%d skipped ( <4 pts )", ri);
#endif
if ( ri ) continue;
else break;
}
#ifdef REPORT_POINTS_REDUCTION
elog(NOTICE, "simplify_polygon3d: ring%d simplified from %d to %d points", ri, iptsn, optsn);
#endif
/*
* Add ring to simplified ring array
* (TODO: dinamic allocation of pts_per_ring)
*/
pts_per_ring[nrings++] = optsn;
if ( ! allptsn ) {
allptsn = optsn;
allpts = palloc(sizeof(POINT3D)*allptsn);
memcpy(allpts, opts, sizeof(POINT3D)*optsn);
} else {
allptsn += optsn;
allpts = repalloc(allpts, sizeof(POINT3D)*allptsn);
memcpy(allpts+(allptsn-optsn), opts, sizeof(POINT3D)*optsn);
}
pfree(opts);
if ( ! allpts ) {
elog(NOTICE, "Error allocating memory for all ring points");
return NULL;
}
}
#ifdef REPORT_RINGS_REDUCTION
elog(NOTICE, "simplify_polygon3d: simplified polygon with %d rings", nrings);
#endif
if ( nrings )
{
opoly = make_polygon(nrings, pts_per_ring, allpts, allptsn, &size);
pfree(allpts);
return (char *)opoly;
}
else
{
return NULL;
}
}
char *
simplify_point3d(POINT3D *ipoint, double dist)
{
return (char *)ipoint;
}
PG_FUNCTION_INFO_V1(simplify);
Datum simplify(PG_FUNCTION_ARGS)
{
Datum datum;
BOX3D *bbox;
GEOMETRY *orig_geom;
GEOMETRY *simp_geom = NULL;
char *orig_obj; /* pointer to each object in orig_geom */
char *simp_obj; /* pointer to each simplified object */
int simp_obj_size; /* size of simplified object */
int32 *offsets;
int i;
double dist;
if ( PG_ARGISNULL(0) ) PG_RETURN_NULL();
datum = PG_GETARG_DATUM(0);
orig_geom = (GEOMETRY *)PG_DETOAST_DATUM(datum);
if ( PG_ARGISNULL(1) ) PG_RETURN_NULL();
dist = PG_GETARG_FLOAT8(1);
/*
* Three or more points on a straight line will still collapse!
*/
// if ( dist == 0 ) PG_RETURN_POINTER(orig_geom);
offsets = (int32 *) ( ((char *) &(orig_geom->objType[0] )) +
sizeof(int32) * orig_geom->nobjs );
/*
* Simplify each subobject indipendently.
* No topology relations kept.
*/
for(i=0;inobjs; i++)
{
orig_obj = (char *) orig_geom+offsets[i];
if ( orig_geom->objType[i] == LINETYPE )
{
simp_obj = simplify_line3d((LINE3D *)orig_obj, dist);
}
else if ( orig_geom->objType[i] == POLYGONTYPE )
{
simp_obj = simplify_polygon3d((POLYGON3D *)orig_obj, dist);
}
else if ( orig_geom->objType[i] == POINTTYPE )
{
simp_obj = simplify_point3d((POINT3D *)orig_obj, dist);
}
else
{
elog(NOTICE, "Unknown geometry type");
PG_RETURN_NULL();
}
/* Simplified object degenerated to empty set */
if ( ! simp_obj ) continue;
/* Get size of simplified object */
simp_obj_size = size_subobject(simp_obj, orig_geom->objType[i]);
/* Create one-object geometry (will add objects later) */
if ( simp_geom == NULL )
{
simp_geom = make_oneobj_geometry(
simp_obj_size, simp_obj, orig_geom->objType[i],
orig_geom->is3d, orig_geom->SRID, orig_geom->scale,
orig_geom->offsetX, orig_geom->offsetY);
}
/* Add object to already initialized geometry */
else
{
simp_geom = add_to_geometry(
simp_geom, simp_obj_size, simp_obj,
orig_geom->objType[i] );
}
/* Error in simplified geometry construction */
if ( ! simp_geom )
{
elog(ERROR, "geometry construction failed at iteration %d", i);
PG_RETURN_NULL();
}
}
if ( simp_geom == NULL ) PG_RETURN_NULL();
/* Calculate the bounding box */
bbox = bbox_of_geometry(simp_geom);
memcpy(&(simp_geom->bvol), bbox, sizeof(BOX3D));
pfree(bbox);
simp_geom->type = orig_geom->type;
PG_RETURN_POINTER(simp_geom);
}
/***********************************************************************
* --strk@keybit.net;
***********************************************************************/
postgis-0.8.1/postgis_chip.c 0100664 0000773 0000144 00000014742 07700351537 015504 0 ustar postgis users
/**********************************************************************
* $Id: postgis_chip.c,v 1.6 2025/07/01 18:30:55 pramsey Exp $
*
* PostGIS - Spatial Types for PostgreSQL
* http://postgis.refractions.net
* Copyright 2001-2003 Refractions Research Inc.
*
* This is free software; you can redistribute and/or modify it under
* the terms of hte GNU General Public Licence. See the COPYING file.
*
**********************************************************************
* $Log: postgis_chip.c,v $
* Revision 1.6 2025/07/01 18:30:55 pramsey
* Added CVS revision headers.
*
*
**********************************************************************/
#include "postgres.h"
#include
#include
#include
#include
#include
#include "access/gist.h"
#include "access/itup.h"
#include "access/rtree.h"
#include "fmgr.h"
#include "postgis.h"
#include "utils/elog.h"
// input is a string with hex chars in it. Convert to binary and put in the result
PG_FUNCTION_INFO_V1(CHIP_in);
Datum CHIP_in(PG_FUNCTION_ARGS)
{
char *str = PG_GETARG_CSTRING(0);
CHIP *result;
int size;
int t;
int input_str_len;
int datum_size;
//printf("chip_in called\n");
input_str_len = strlen(str);
if ( ( ( (int)(input_str_len/2.0) ) *2.0) != input_str_len)
{
elog(ERROR,"CHIP_in parser - should be even number of characters!");
PG_RETURN_NULL();
}
if (strspn(str,"0123456789ABCDEF") != strlen(str) )
{
elog(ERROR,"CHIP_in parser - input contains bad characters. Should only have '0123456789ABCDEF'!");
PG_RETURN_NULL();
}
size = (input_str_len/2) ;
result = (CHIP *) palloc(size);
for (t=0;tsize = size;
if (result->size < sizeof(CHIP) )
{
elog(ERROR,"CHIP_in parser - bad data (too small to be a CHIP)!");
PG_RETURN_NULL();
}
if (result->endian_hint != 1)
{
//need to do an endian flip
flip_endian_int32( (char *) &result->endian_hint);
flip_endian_double((char *) &result->bvol.LLB.x);
flip_endian_double((char *) &result->bvol.LLB.y);
flip_endian_double((char *) &result->bvol.LLB.z);
flip_endian_double((char *) &result->bvol.URT.x);
flip_endian_double((char *) &result->bvol.URT.y);
flip_endian_double((char *) &result->bvol.URT.z);
flip_endian_int32( (char *) & result->SRID);
//dont know what to do with future[8] ...
flip_endian_int32( (char *) & result->height);
flip_endian_int32( (char *) & result->width);
flip_endian_int32( (char *) & result->compression);
flip_endian_int32( (char *) & result->factor);
flip_endian_int32( (char *) & result->datatype);
}
if (result->endian_hint != 1 )
{
elog(ERROR,"CHIP_in parser - bad data (endian flag != 1)!");
PG_RETURN_NULL();
}
datum_size = 4;
if ( (result->datatype == 6) || (result->datatype == 7) || (result->datatype == 106) || (result->datatype == 107) )
{
datum_size = 2;
}
if ( (result->datatype == 8) || (result->datatype == 108) )
{
datum_size=1;
}
if (result->compression ==0) //only true for non-compressed data
{
if (result->size != (sizeof(CHIP) + datum_size * result->width*result->height) )
{
elog(ERROR,"CHIP_in parser - bad data (actual size != computed size)!");
PG_RETURN_NULL();
}
}
PG_RETURN_POINTER(result);
}
//given a CHIP structure, convert it to Hex and put it in a string
PG_FUNCTION_INFO_V1(CHIP_out);
Datum CHIP_out(PG_FUNCTION_ARGS)
{
CHIP *chip = (CHIP *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
char *result;
int size_result;
int t;
//printf("chip_out called\n");
size_result = (chip->size ) *2 +1; //+1 for null char
result = palloc (size_result);
result[size_result-1] = 0; //null terminate
for (t=0; t< (chip->size); t++)
{
deparse_hex( ((unsigned char *) chip)[t], &result[t*2]);
}
PG_RETURN_CSTRING(result);
}
PG_FUNCTION_INFO_V1(CHIP_to_geom);
Datum CHIP_to_geom(PG_FUNCTION_ARGS)
{
CHIP *chip = (CHIP *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
GEOMETRY *result;
POLYGON3D *poly;
POINT3D pts[5]; //5 points around box
int pts_per_ring[1];
int poly_size;
//use LLB's z value (we're going to set is3d to false)
set_point( &pts[0], chip->bvol.LLB.x , chip->bvol.LLB.y , chip->bvol.LLB.z );
set_point( &pts[1], chip->bvol.URT.x , chip->bvol.LLB.y , chip->bvol.LLB.z );
set_point( &pts[2], chip->bvol.URT.x , chip->bvol.URT.y , chip->bvol.LLB.z );
set_point( &pts[3], chip->bvol.LLB.x , chip->bvol.URT.y , chip->bvol.LLB.z );
set_point( &pts[4], chip->bvol.LLB.x , chip->bvol.LLB.y , chip->bvol.LLB.z );
pts_per_ring[0] = 5; //ring has 5 points
//make a polygon
poly = make_polygon(1, pts_per_ring, pts, 5, &poly_size);
result = make_oneobj_geometry(poly_size, (char *)poly, POLYGONTYPE, FALSE,chip->SRID, 1.0, 0.0, 0.0);
PG_RETURN_POINTER(result);
}
PG_FUNCTION_INFO_V1(srid_chip);
Datum srid_chip(PG_FUNCTION_ARGS)
{
CHIP *c = (CHIP *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
PG_RETURN_INT32(c->SRID);
}
PG_FUNCTION_INFO_V1(factor_chip);
Datum factor_chip(PG_FUNCTION_ARGS)
{
CHIP *c = (CHIP *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
PG_RETURN_FLOAT4(c->factor);
}
PG_FUNCTION_INFO_V1(datatype_chip);
Datum datatype_chip(PG_FUNCTION_ARGS)
{
CHIP *c = (CHIP *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
PG_RETURN_INT32(c->datatype);
}
PG_FUNCTION_INFO_V1(compression_chip);
Datum compression_chip(PG_FUNCTION_ARGS)
{
CHIP *c = (CHIP *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
PG_RETURN_INT32(c->compression);
}
PG_FUNCTION_INFO_V1(height_chip);
Datum height_chip(PG_FUNCTION_ARGS)
{
CHIP *c = (CHIP *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
PG_RETURN_INT32(c->height);
}
PG_FUNCTION_INFO_V1(width_chip);
Datum width_chip(PG_FUNCTION_ARGS)
{
CHIP *c = (CHIP *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
PG_RETURN_INT32(c->width);
}
PG_FUNCTION_INFO_V1(setsrid_chip);
Datum setsrid_chip(PG_FUNCTION_ARGS)
{
CHIP *c = (CHIP *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
int32 new_srid = PG_GETARG_INT32(1);
CHIP *result;
result = (CHIP *) palloc(c->size);
memcpy(result,c,c->size);
result->SRID = new_srid;
PG_RETURN_POINTER(result);
}
PG_FUNCTION_INFO_V1(setfactor_chip);
Datum setfactor_chip(PG_FUNCTION_ARGS)
{
CHIP *c = (CHIP *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
float factor = PG_GETARG_FLOAT4(1);
CHIP *result;
result = (CHIP *) palloc(c->size);
memcpy(result,c,c->size);
result->factor = factor;
PG_RETURN_POINTER(result);
}
postgis-0.8.1/postgis_debug.c 0100664 0000773 0000144 00000020316 07756727773 015665 0 ustar postgis users
/**********************************************************************
* $Id: postgis_debug.c,v 1.13 2025/11/19 18:01:31 strk Exp $
*
* PostGIS - Spatial Types for PostgreSQL
* http://postgis.refractions.net
* Copyright 2001-2003 Refractions Research Inc.
*
* This is free software; you can redistribute and/or modify it under
* the terms of hte GNU General Public Licence. See the COPYING file.
*
**********************************************************************
* $Log: postgis_debug.c,v $
* Revision 1.13 2025/11/19 18:01:31 strk
* CR removed
*
* Revision 1.12 2025/09/16 20:27:12 dblasby
* added ability to delete geometries.
*
* Revision 1.11 2025/08/08 18:19:20 dblasby
* Conformance changes.
* Removed junk from postgis_debug.c and added the first run of the long
* transaction locking support. (this will change - dont use it)
* conformance tests were corrected
* some dos cr/lf removed
* empty geometries i.e. GEOMETRYCOLLECT(EMPTY) added (with indexing support)
* pointN(,1) now returns the first point (used to return 2nd)
*
* Revision 1.10 2025/07/25 17:08:37 pramsey
* Moved Cygwin endian define out of source files into postgis.h common
* header file.
*
* Revision 1.9 2025/07/01 18:30:55 pramsey
* Added CVS revision headers.
*
*
**********************************************************************/
#include "postgres.h"
#include
#include
#include
#include
#include
#include "access/gist.h"
#include "access/itup.h"
#include "access/rtree.h"
#include "fmgr.h"
#include "postgis.h"
#include "utils/elog.h"
#include "executor/spi.h"
#include "commands/trigger.h"
#define SHOW_DIGS_DOUBLE 15
#define MAX_DIGS_DOUBLE (SHOW_DIGS_DOUBLE + 6 + 1 + 3 +1)
// #define DEBUG_GIST
//#define DEBUG_GIST2
//find the size of geometry
PG_FUNCTION_INFO_V1(mem_size);
Datum mem_size(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
PG_RETURN_INT32(geom1->size);
}
//get summary info on a GEOMETRY
PG_FUNCTION_INFO_V1(summary);
Datum summary(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
int32 *offsets1;
char *o1;
int32 type1,j,i;
POLYGON3D *poly;
LINE3D *line;
char *result;
int size;
char tmp[100];
text *mytext;
size = 1;
result = palloc(1);
result[0] = 0; //null terminate it
offsets1 = (int32 *) ( ((char *) &(geom1->objType[0] ))+ sizeof(int32) * geom1->nobjs ) ;
//now have to do a scan of each object
for (j=0; j< geom1->nobjs; j++) //for each object in geom1
{
o1 = (char *) geom1 +offsets1[j] ;
type1= geom1->objType[j];
if (type1 == POINTTYPE) //point
{
size += 30;
result = repalloc(result,size);
sprintf(tmp,"Object %i is a POINT()\n",j);
strcat(result,tmp);
}
if (type1 == LINETYPE) //line
{
line = (LINE3D *) o1;
size += 57;
result = repalloc(result,size);
sprintf(tmp,"Object %i is a LINESTRING() with %i points\n",j,line->npoints);
strcat(result,tmp);
}
if (type1 == POLYGONTYPE) //POLYGON
{
poly = (POLYGON3D *) o1;
size += 57*(poly->nrings +1);
result = repalloc(result,size);
sprintf(tmp,"Object %i is a POLYGON() with %i rings\n",j,poly->nrings);
strcat(result,tmp);
for (i=0; inrings;i++)
{
sprintf(tmp," + ring %i has %i points\n",i,poly->npoints[i]);
strcat(result,tmp);
}
}
}
// create a text obj to return
mytext = (text *) palloc(VARHDRSZ + strlen(result) );
VARATT_SIZEP(mytext) = VARHDRSZ + strlen(result) ;
memcpy(VARDATA(mytext) , result, strlen(result) );
pfree(result);
PG_RETURN_POINTER(mytext);
}
extern Datum lockcheck(PG_FUNCTION_ARGS);
PG_FUNCTION_INFO_V1(lockcheck);
Datum lockcheck (PG_FUNCTION_ARGS)
{
TriggerData *trigdata = (TriggerData *) fcinfo->context;
char *colname ;
int id;
HeapTuple rettuple;
TupleDesc tupdesc;
int SPIcode;
char *relname;
bool isnull;
char query[1024];
int pk_type_oid;
char *pk_id = NULL;
elog(NOTICE,"in lockcheck()");
/* Make sure trigdata is pointing at what I expect */
if (!CALLED_AS_TRIGGER(fcinfo))
elog(ERROR, "lockcheck: not fired by trigger manager");
rettuple = trigdata->tg_newtuple;
tupdesc = trigdata->tg_relation->rd_att;
/* Connect to SPI manager */
SPIcode = SPI_connect();
if (SPIcode != SPI_OK_CONNECT)
{
elog(ERROR,"lockcheck: couldnt open a connection to SPI");
PG_RETURN_NULL() ;
}
relname = SPI_getrelname(trigdata->tg_relation);
colname = trigdata->tg_trigger->tgargs[0];
elog(NOTICE,"trigger was executed on the relation: '%s', with attribute named '%s', with locktable named '%s'", relname,colname,"authorization_table");
//get the value
pk_type_oid =SPI_gettypeid ( tupdesc , SPI_fnumber(tupdesc,colname));
elog(NOTICE,"primary key type # = %i", pk_type_oid ) ;
if (pk_type_oid == 23) //int4
{
int id = (int) DatumGetInt32( SPI_getbinval(rettuple, tupdesc, SPI_fnumber(tupdesc,colname), &isnull) );
if (isnull)
{
elog(ERROR,"lockcheck - column (%s) of table (%s) is null!",colname,relname);
}
pk_id = palloc(100);
sprintf(pk_id,"%i",id);
}
else if (pk_type_oid == 25) // text
{
Datum id = ( SPI_getbinval(rettuple, tupdesc, SPI_fnumber(tupdesc,colname), &isnull) );
if (isnull)
{
elog(ERROR,"lockcheck - column (%s) of table (%s) is null!",colname,relname);
}
pk_id = DatumGetCString(DirectFunctionCall1(textout,id));
}
else if (pk_type_oid == 1043) // varchar
{
Datum id = ( SPI_getbinval(rettuple, tupdesc, SPI_fnumber(tupdesc,colname), &isnull) );
if (isnull)
{
elog(ERROR,"lockcheck - column (%s) of table (%s) is null!",colname,relname);
}
pk_id = DatumGetCString(DirectFunctionCall1(varcharout,id));
}
else
{
elog(ERROR,"id column (%s) of table (%s) has to be either int4, text, or varchar. Its - %s (oid %i)",colname,relname,SPI_gettype ( tupdesc , SPI_fnumber(tupdesc,colname) ) ,pk_type_oid );
}
id = (int) DatumGetInt32( SPI_getbinval(rettuple, tupdesc, SPI_fnumber(tupdesc,colname), &isnull) );
sprintf(query,"SELECT authid FROM %s WHERE expires >= now() AND tname = '%s' and fid = '%s'::text", "authorization_table",relname,pk_id);
elog(NOTICE,"about to execute :%s", query);
SPIcode = SPI_exec(query,0);
if (SPIcode !=SPI_OK_SELECT )
elog(ERROR,"couldnt execute to test for lock :%s",query);
if (SPI_processed >0)
{
// there is a lock - check to see if I have rights to it!
TupleDesc tupdesc = SPI_tuptable->tupdesc;
SPITupleTable *tuptable = SPI_tuptable;
HeapTuple tuple = tuptable->vals[0];
char *lockcode = SPI_getvalue(tuple, tupdesc, 1);
elog(NOTICE,"there is a lock on this row!");
// check to see if temp_lock_have_table table exists (it might not exist if they own no locks
sprintf(query,"SELECT * FROM pg_class WHERE relname = 'temp_lock_have_table'");
SPIcode = SPI_exec(query,0);
if (SPIcode !=SPI_OK_SELECT )
elog(ERROR,"couldnt execute to test for lockkey temp table :%s",query);
if (SPI_processed ==0)
{
elog(NOTICE,"I do not own any locks (no lock table) - I cannot modify the row");
//PG_RETURN_NULL();
SPI_finish();
//return NULL;
elog(ERROR,"attemted to modify a locked row that I do not have authorization for!");
}
sprintf(query,"SELECT * FROM temp_lock_have_table WHERE xideq(transid , getTransactionID() ) AND lockcode ='%s'",lockcode);
elog(NOTICE,"about to execute :%s", query);
SPIcode = SPI_exec(query,0);
if (SPIcode !=SPI_OK_SELECT )
elog(ERROR,"couldnt execute to test for lock aquire:%s",query);
if (SPI_processed >0)
{
elog(NOTICE,"I own the lock - I can modify the row");
SPI_finish();
return PointerGetDatum(rettuple);
}
elog(NOTICE,"I do not own the lock - I cannot modify the row");
//PG_RETURN_NULL();
SPI_finish();
//return NULL;
elog(ERROR,"attemted to modify a locked row that I do not have authorization for!");
}
else
{
elog(NOTICE,"there is NOT a lock on this row!");
SPI_finish();
return PointerGetDatum(rettuple);
}
}
extern Datum getTransactionID(PG_FUNCTION_ARGS);
PG_FUNCTION_INFO_V1(getTransactionID);
Datum getTransactionID(PG_FUNCTION_ARGS)
{
TransactionId xid = GetCurrentTransactionId();
PG_RETURN_DATUM( TransactionIdGetDatum(xid) );
}
postgis-0.8.1/postgis_estimate.c 0100664 0000773 0000144 00000060464 07754133241 016375 0 ustar postgis users
/**********************************************************************
* $Id: postgis_estimate.c,v 1.7 2025/11/11 10:14:57 strk Exp $
*
* PostGIS - Spatial Types for PostgreSQL
* http://postgis.refractions.net
* Copyright 2001-2003 Refractions Research Inc.
*
* This is free software; you can redistribute and/or modify it under
* the terms of hte GNU General Public Licence. See the COPYING file.
*
**********************************************************************
* $Log: postgis_estimate.c,v $
* Revision 1.7 2025/11/11 10:14:57 strk
* Added support for PG74
*
* Revision 1.6 2025/07/25 17:08:37 pramsey
* Moved Cygwin endian define out of source files into postgis.h common
* header file.
*
* Revision 1.5 2025/07/01 18:30:55 pramsey
* Added CVS revision headers.
*
*
**********************************************************************/
// If you're modifiying this file you should read the postgis mail list as it has
// detailed descriptions of whats happening here and why.
#include "postgres.h"
#include
#include
#include
#include
#include
#include "access/gist.h"
#include "access/itup.h"
#include "access/rtree.h"
#include "fmgr.h"
#include "postgis.h"
#include "utils/elog.h"
#define SHOW_DIGS_DOUBLE 15
#define MAX_DIGS_DOUBLE (SHOW_DIGS_DOUBLE + 6 + 1 + 3 +1)
//--------------------------------------------------------------------------
#include "access/heapam.h"
#include "catalog/catname.h"
#include "catalog/pg_operator.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_statistic.h"
#include "catalog/pg_type.h"
#include "mb/pg_wchar.h"
#include "nodes/makefuncs.h"
#include "optimizer/clauses.h"
#include "optimizer/cost.h"
#include "optimizer/pathnode.h"
#include "optimizer/plancat.h"
#include "optimizer/prep.h"
#include "parser/parse_func.h"
#include "parser/parse_oper.h"
#include "parser/parsetree.h"
#include "utils/builtins.h"
#include "utils/date.h"
#include "utils/int8.h"
#include "utils/lsyscache.h"
#include "utils/selfuncs.h"
#include "utils/syscache.h"
#include "executor/spi.h"
//estimate_histogram2d(histogram2d, box)
// returns a % estimate of the # of features that will be returned by that box query
//
//For each grid cell that intersects the query box
// Calculate area of intersection (AOI)
// IF AOI < avgFeatureArea THEN set AOI = avgFeatureArea
// SUM AOI/area-of-cell*value-of-cell
//
// change : instead of avgFeatureArea, use avgFeatureArea or 10% of a grid cell (whichever is smaller)
PG_FUNCTION_INFO_V1(estimate_histogram2d);
Datum estimate_histogram2d(PG_FUNCTION_ARGS)
{
HISTOGRAM2D *histo = (HISTOGRAM2D *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
BOX *box = (BOX *) PG_GETARG_POINTER(1);
double box_area;
int x_idx_min, x_idx_max, y_idx_min, y_idx_max;
double intersect_x, intersect_y,AOI;
int x,y;
double xmin,ymin,xmax,ymax;
int32 result_sum;
double cell_area;
int total,t;
double avg_feature_size;
result_sum = 0;
xmin = histo->xmin;
ymin = histo->ymin;
xmax = histo->xmax;
ymax = histo->ymax;
cell_area = ( (xmax-xmin)*(ymax-ymin)/(histo->boxesPerSide*histo->boxesPerSide) );
avg_feature_size = histo->avgFeatureArea;
if ( avg_feature_size > cell_area*0.1)
{
avg_feature_size = cell_area*0.1;
}
//elog(NOTICE,"start estimate_histogram2d: ");
//elog(NOTICE,"box is : (%.15g,%.15g to %.15g,%.15g)",box->low.x,box->low.y, box->high.x, box->high.y);
box_area = (box->high.x-box->low.x)*(box->high.y-box->low.y);
if (box_area<0)
box_area =0; // for precision!
//check to see which boxes this intersects
x_idx_min = (box->low.x-xmin)/(xmax-xmin)*histo->boxesPerSide;
if (x_idx_min <0)
x_idx_min = 0;
if (x_idx_min >= histo->boxesPerSide)
x_idx_min = histo->boxesPerSide-1;
y_idx_min = (box->low.y-ymin)/(ymax-ymin)*histo->boxesPerSide;
if (y_idx_min <0)
y_idx_min = 0;
if (y_idx_min >= histo->boxesPerSide)
y_idx_min = histo->boxesPerSide-1;
x_idx_max = (box->high.x-xmin)/(xmax-xmin)*histo->boxesPerSide;
if (x_idx_max <0)
x_idx_max = 0;
if (x_idx_max >= histo->boxesPerSide)
x_idx_max = histo->boxesPerSide-1;
y_idx_max = (box->high.y-ymin)/(ymax-ymin)*histo->boxesPerSide ;
if (y_idx_max <0)
y_idx_max = 0;
if (y_idx_max >= histo->boxesPerSide)
y_idx_max = histo->boxesPerSide-1;
//the {x,y}_idx_{min,max} define the grid squares that the box intersects
//elog(NOTICE," search is in x: %i to %i y: %i to %i",x_idx_min, x_idx_max, y_idx_min,y_idx_max);
for (y= y_idx_min; y<=y_idx_max;y++)
{
for (x=x_idx_min;x<= x_idx_max;x++)
{
intersect_x = min(box->high.x, xmin+ (x+1) * (xmax-xmin)/histo->boxesPerSide ) -
max(box->low.x, xmin+ x*(xmax-xmin)/histo->boxesPerSide ) ;
intersect_y = min(box->high.y, ymin+ (y+1) * (ymax-ymin)/histo->boxesPerSide ) -
max(box->low.y, ymin+ y*(ymax-ymin)/histo->boxesPerSide ) ;
// for a point, intersect_x=0, intersect_y=0, box_area =0
//elog(NOTICE,"x=%i,y=%i, intersect_x= %.15g, intersect_y = %.15g",x,y,intersect_x,intersect_y);
if ( (intersect_x>=0) && (intersect_y>=0) )
{
AOI = intersect_x*intersect_y;
if (AOI< avg_feature_size)
AOI = avg_feature_size;
result_sum += AOI/cell_area* histo->value[x+y*histo->boxesPerSide];
}
}
}
total = 0;
for(t=0;tboxesPerSide*histo->boxesPerSide;t++)
{
total+=histo->value[t];
}
if ( (histo->avgFeatureArea <=0) && (box_area <=0) )
PG_RETURN_FLOAT8(1.0/((double)(total)));
else
PG_RETURN_FLOAT8(result_sum/((double)total));
}
//explode_histogram2d(histogram2d, tablename::text)
// executes CREATE TABLE tablename (the_geom geometry, id int, hits int, percent float)
// then populates it
// DOES NOT UPDATE GEOMETRY_COLUMNS
PG_FUNCTION_INFO_V1(explode_histogram2d);
Datum explode_histogram2d(PG_FUNCTION_ARGS)
{
HISTOGRAM2D *histo = (HISTOGRAM2D *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
char *tablename;
char sql[1000];
char geom[1000];
int t;
int total;
double cellx,celly;
int x,y;
int SPIcode;
cellx = (histo->xmax-histo->xmin)/histo->boxesPerSide;
celly = (histo->ymax-histo->ymin)/histo->boxesPerSide;
tablename = DatumGetCString(DirectFunctionCall1(textout,
PointerGetDatum(PG_GETARG_DATUM(1))));
total = 0;
for(t=0;tboxesPerSide*histo->boxesPerSide;t++)
{
total+=histo->value[t];
}
if (total==0)
total=1;
SPIcode = SPI_connect();
if (SPIcode != SPI_OK_CONNECT)
{
elog(ERROR,"build_histogram2d: couldnt open a connection to SPI");
PG_RETURN_NULL() ;
}
sprintf(sql,"CREATE TABLE %s (the_geom geometry, id int, hits int, percent float)",tablename);
SPIcode = SPI_exec(sql, 2147483640 ); // max signed int32
if (SPIcode != SPI_OK_UTILITY )
{
elog(ERROR,"explode_histogram2d: couldnt create table");
PG_RETURN_NULL() ;
}
t=0;
for(y=0;yboxesPerSide;y++)
{
for(x=0;xboxesPerSide;x++)
{
sprintf(geom,"POLYGON((%.15g %.15g, %.15g %.15g, %.15g %.15g, %.15g %.15g, %.15g %.15g ))",
histo->xmin + x*cellx, histo->ymin+y*celly,
histo->xmin + (x)*cellx, histo->ymin+ (y+1)*celly,
histo->xmin + (x+1)*cellx, histo->ymin+ (y+1)*celly,
histo->xmin + (x+1)*cellx, histo->ymin+y*celly,
histo->xmin + x*cellx, histo->ymin+y*celly
);
sprintf(sql,"INSERT INTO %s VALUES('%s'::geometry,%i,%i,%.15g)",tablename,geom,t,histo->value[t],histo->value[t]/((double)total)*100.0);
//elog(NOTICE,"SQL:%s",sql);
t++;
SPIcode = SPI_exec(sql, 2147483640 ); // max signed int32
if (SPIcode != SPI_OK_INSERT )
{
elog(ERROR,"explode_histogram2d: couldnt insert into");
PG_RETURN_NULL() ;
}
}
}
SPIcode =SPI_finish();
if (SPIcode != SPI_OK_FINISH )
{
elog(ERROR,"build_histogram2d: couldnt disconnect from SPI");
PG_RETURN_NULL() ;
}
PG_RETURN_POINTER(histo) ;
}
//build_histogram2d (HISTOGRAM2D, tablename, columnname)
// executes the SPI 'SELECT box3d(columnname) FROM tablename'
// and sticks all the results in the histogram
PG_FUNCTION_INFO_V1(build_histogram2d);
Datum build_histogram2d(PG_FUNCTION_ARGS)
{
HISTOGRAM2D *histo = (HISTOGRAM2D *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
char *tablename, *columnname;
HISTOGRAM2D *result;
int SPIcode;
char sql[1000];
SPITupleTable *tuptable;
TupleDesc tupdesc ;
int ntuples,t;
Datum datum;
bool isnull;
HeapTuple tuple ;
BOX *box;
double box_area, area_intersect, cell_area;
int x_idx_min, x_idx_max;
int y_idx_min, y_idx_max;
double xmin,ymin, xmax,ymax;
double intersect_x, intersect_y;
int x,y;
int total;
double sum_area;
int sum_area_numb;
double sum_area_new = 0;
int sum_area_numb_new =0;
int bump=0;
int tuplimit = 500000; // No. of tuples returned on each cursor fetch
bool moredata;
void *SPIplan;
void *SPIportal;
xmin = histo->xmin;
ymin = histo->ymin;
xmax = histo->xmax;
ymax = histo->ymax;
result = (HISTOGRAM2D *) malloc(histo->size);
memcpy(result,histo,histo->size);
total = 0;
for(t=0;tboxesPerSide*histo->boxesPerSide;t++)
{
total+=histo->value[t];
}
sum_area = histo->avgFeatureArea * total;
sum_area_numb = total;
tablename = DatumGetCString(DirectFunctionCall1(textout,
PointerGetDatum(PG_GETARG_DATUM(1))));
columnname = DatumGetCString(DirectFunctionCall1(textout,
PointerGetDatum(PG_GETARG_DATUM(2))));
//elog(NOTICE,"Start build_histogram2d with %i items already existing", sum_area_numb);
//elog(NOTICE,"table=\"%s\", column = \"%s\"", tablename, columnname);
SPIcode = SPI_connect();
if (SPIcode != SPI_OK_CONNECT)
{
elog(ERROR,"build_histogram2d: couldnt open a connection to SPI");
PG_RETURN_NULL() ;
}
sprintf(sql,"SELECT box(\"%s\") FROM \"%s\"",columnname,tablename);
//elog(NOTICE,"executing %s",sql);
SPIplan = SPI_prepare(sql, 0, NULL);
if (SPIplan == NULL)
{
elog(ERROR,"build_histogram2d: couldnt create query plan via SPI");
PG_RETURN_NULL() ;
}
SPIportal = SPI_cursor_open(NULL, SPIplan, NULL, NULL);
if (SPIportal == NULL)
{
elog(ERROR,"build_histogram2d: couldn't create cursor via SPI");
PG_RETURN_NULL() ;
}
moredata = TRUE;
while (moredata==TRUE) {
//elog(NOTICE,"about to fetch...");
SPI_cursor_fetch(SPIportal, TRUE, tuplimit);
ntuples = SPI_processed;
//elog(NOTICE,"processing %d records", ntuples);
if (ntuples > 0) {
tuptable = SPI_tuptable;
tupdesc = SPI_tuptable->tupdesc;
cell_area = ( (xmax-xmin)*(ymax-ymin)/(histo->boxesPerSide*histo->boxesPerSide) );
for (t=0;tvals[t];
datum = SPI_getbinval(tuple, tupdesc, 1, &isnull);
if (!(isnull))
{
box = (BOX *)DatumGetPointer(datum);
box_area = (box->high.x-box->low.x)*(box->high.y-box->low.y);
sum_area_new += box_area;
sum_area_numb_new ++;
if (box_area > cell_area )
box_area = cell_area;
if (box_area<0)
box_area =0; // for precision!
//check to see which boxes this intersects
x_idx_min = (box->low.x-xmin)/(xmax-xmin)*histo->boxesPerSide;
if (x_idx_min <0)
x_idx_min = 0;
if (x_idx_min >= histo->boxesPerSide)
x_idx_min = histo->boxesPerSide-1;
y_idx_min = (box->low.y-ymin)/(ymax-ymin)*histo->boxesPerSide;
if (y_idx_min <0)
y_idx_min = 0;
if (y_idx_min >= histo->boxesPerSide)
y_idx_min = histo->boxesPerSide-1;
x_idx_max = (box->high.x-xmin)/(xmax-xmin)*histo->boxesPerSide;
if (x_idx_max <0)
x_idx_max = 0;
if (x_idx_max >= histo->boxesPerSide)
x_idx_max = histo->boxesPerSide-1;
y_idx_max = (box->high.y-ymin)/(ymax-ymin)*histo->boxesPerSide ;
if (y_idx_max <0)
y_idx_max = 0;
if (y_idx_max >= histo->boxesPerSide)
y_idx_max = histo->boxesPerSide-1;
//the {x,y}_idx_{min,max} define the grid squares that the box intersects
// if the area of the intersect between the box and the grid square > 5% of
//elog(NOTICE,"box is : (%.15g,%.15g to %.15g,%.15g)",box->low.x,box->low.y, box->high.x, box->high.y);
//elog(NOTICE," search is in x: %i to %i y: %i to %i",x_idx_min, x_idx_max, y_idx_min,y_idx_max);
for (y= y_idx_min; y<=y_idx_max;y++)
{
for (x=x_idx_min;x<= x_idx_max;x++)
{
intersect_x = min(box->high.x, xmin+ (x+1) * (xmax-xmin)/histo->boxesPerSide ) -
max(box->low.x, xmin+ x*(xmax-xmin)/histo->boxesPerSide ) ;
intersect_y = min(box->high.y, ymin+ (y+1) * (ymax-ymin)/histo->boxesPerSide ) -
max(box->low.y, ymin+ y*(ymax-ymin)/histo->boxesPerSide ) ;
// for a point, intersect_x=0, intersect_y=0, box_area =0
//elog(NOTICE,"x=%i,y=%i, intersect_x= %.15g, intersect_y = %.15g",x,y,intersect_x,intersect_y);
if ( (intersect_x>=0) && (intersect_y>=0) )
{
area_intersect = intersect_x*intersect_y;
if (area_intersect >= box_area*0.05)
{
//elog(NOTICE,"bump");
bump++;
result->value[x+y*histo->boxesPerSide]++;
}
}
}
} // End of y
} // End isnull
} // End of for loop
// Free all the results after each fetch, otherwise all tuples stay
// in memory until the end of the table...
SPI_freetuptable(tuptable);
} else {
moredata = FALSE;
} // End of if ntuples > 0
} // End of while loop
// Close the cursor
SPI_cursor_close(SPIportal);
SPIcode =SPI_finish();
if (SPIcode != SPI_OK_FINISH )
{
elog(ERROR,"build_histogram2d: couldnt disconnect from SPI");
PG_RETURN_NULL() ;
}
//elog(NOTICE,"finishing up build_histogram2d ");
//pfree(tablename);
//pfree(columnname);
total = 0;
for(t=0;tboxesPerSide*histo->boxesPerSide;t++)
{
total+=result->value[t];
}
//elog(NOTICE ,"histogram finishes with %i items in it - acutally added %i rows and %i bumps\n",total,sum_area_numb_new,bump);
//elog(NOTICE,"done build_histogram2d ");
//re-calculate statistics on avg bbox size
if (sum_area_numb_new >0)
result->avgFeatureArea = (sum_area_new+sum_area)/((double)(sum_area_numb_new+sum_area_numb));
PG_RETURN_POINTER(result) ;
}
/*
* get_restriction_var
* Examine the args of a restriction clause to see if it's of the
* form (var op something) or (something op var). If so, extract
* and return the var and the other argument.
*
* Inputs:
* args: clause argument list
* varRelid: see specs for restriction selectivity functions
*
* Outputs: (these are set only if TRUE is returned)
* *var: gets Var node
* *other: gets other clause argument
* *varonleft: set TRUE if var is on the left, FALSE if on the right
*
* Returns TRUE if a Var is identified, otherwise FALSE.
*/
static bool
get_restriction_var(List *args,
int varRelid,
Var **var,
Node **other,
bool *varonleft)
{
Node *left,
*right;
if (length(args) != 2)
return false;
left = (Node *) lfirst(args);
right = (Node *) lsecond(args);
/* Ignore any binary-compatible relabeling */
if (IsA(left, RelabelType))
left = (Node *)((RelabelType *) left)->arg;
if (IsA(right, RelabelType))
right = (Node *)((RelabelType *) right)->arg;
/* Look for the var */
if (IsA(left, Var) &&
(varRelid == 0 || varRelid == ((Var *) left)->varno))
{
*var = (Var *) left;
*other = right;
*varonleft = true;
}
else if (IsA(right, Var) &&
(varRelid == 0 || varRelid == ((Var *) right)->varno))
{
*var = (Var *) right;
*other = left;
*varonleft = false;
}
else
{
/* Duh, it's too complicated for me... */
return false;
}
return true;
}
//restriction in the GiST && operator
PG_FUNCTION_INFO_V1(postgis_gist_sel);
Datum postgis_gist_sel(PG_FUNCTION_ARGS)
{
Query *root = (Query *) PG_GETARG_POINTER(0);
// Oid operator = PG_GETARG_OID(1);
List *args = (List *) PG_GETARG_POINTER(2);
int varRelid = PG_GETARG_INT32(3);
GEOMETRY *in;
BOX *search_box;
char sql[1000];
SPITupleTable *tuptable;
TupleDesc tupdesc ;
HeapTuple tuple ;
Datum datum;
bool isnull;
Var *var;
Node *other;
bool varonleft;
Oid relid;
int SPIcode;
double myest;
#ifndef USE_STATS
PG_RETURN_FLOAT8(0.000005);
#endif
//PG_RETURN_FLOAT8(0.000005);
//elog(NOTICE,"postgis_gist_sel was called");
if (!get_restriction_var(args, varRelid,
&var, &other, &varonleft))
{
//elog(NOTICE,"get_restriction_var FAILED -returning early");
PG_RETURN_FLOAT8(0.000005);
}
relid = getrelid(var->varno, root->rtable);
if (relid == InvalidOid)
{
//elog(NOTICE,"getrelid FAILED (invalid oid) -returning early");
PG_RETURN_FLOAT8(0.000005);
}
//elog(NOTICE,"operator's oid = %i (this should be GEOMETRY && GEOMETRY)",operator);
//elog(NOTICE,"relations' oid = %i (this should be the relation that the && is working on) ",relid);
//elog(NOTICE,"varatt oid = %i (basically relations column #) ",var->varattno);
if (IsA(other, Const) &&((Const *) other)->constisnull)
{
//elog(NOTICE,"other operand of && is NULL - returning early");
PG_RETURN_FLOAT8(0.000005);
}
if (IsA(other, Const))
{
//elog(NOTICE,"The other side of the && is a constant with type (oid) = %i and length %i. This should be GEOMETRY with length -1 (variable length)",((Const*)other)->consttype,((Const*)other)->constlen);
}
else
{
//elog(NOTICE,"the other side of && isnt a constant - returning early");
PG_RETURN_FLOAT8(0.000005);
}
//get the BOX thats being searched in
in = (GEOMETRY*)PG_DETOAST_DATUM( ((Const*)other)->constvalue );
search_box = convert_box3d_to_box(&in->bvol);
//elog(NOTICE,"requested search box is : (%.15g %.15g, %.15g %.15g)",search_box->low.x,search_box->low.y,search_box->high.x,search_box->high.y);
SPIcode = SPI_connect();
if (SPIcode != SPI_OK_CONNECT)
{
elog(NOTICE,"postgis_gist_sel: couldnt open a connection to SPI:%i",SPIcode);
PG_RETURN_FLOAT8(0.000005) ;
}
sprintf(sql,"SELECT stats FROM GEOMETRY_COLUMNS WHERE attrelid=%u AND varattnum=%i",relid,var->varattno);
//elog(NOTICE,"sql:%s",sql);
SPIcode = SPI_exec(sql, 1 );
if (SPIcode != SPI_OK_SELECT )
{
SPI_finish();
elog(NOTICE,"postgis_gist_sel: couldnt execute sql via SPI");
PG_RETURN_FLOAT8(0.000005) ;
}
if (SPI_processed !=1)
{
SPI_finish();
//elog(NOTICE,"postgis_gist_sel: geometry_columns didnt return a unique value");
PG_RETURN_FLOAT8(0.000005) ;
}
tuptable = SPI_tuptable;
tupdesc = SPI_tuptable->tupdesc;
tuple = tuptable->vals[0];
datum = SPI_getbinval(tuple, tupdesc, 1, &isnull);
if (isnull)
{
SPI_finish();
//elog(NOTICE,"postgis_gist_sel: geometry_columns returned a null histogram");
PG_RETURN_FLOAT8(0.000005) ;
}
//elog(NOTICE,"postgis_gist_sel: checking against estimate_histogram2d");
// now we have the histogram, and our search box - use the estimate_histogram2d(histo,box) to get the result!
myest =
DatumGetFloat8( DirectFunctionCall2( estimate_histogram2d, datum, PointerGetDatum(search_box) ) );
if ( (myest<0) || (myest!=myest) ) // <0? or NaN?
{
//elog(NOTICE,"postgis_gist_sel: got something crazy back from estimate_histogram2d");
PG_RETURN_FLOAT8(0.000005) ;
}
SPIcode =SPI_finish();
if (SPIcode != SPI_OK_FINISH )
{
//elog(NOTICE,"postgis_gist_sel: couldnt disconnect from SPI");
PG_RETURN_FLOAT8(0.000005) ;
}
//elog(NOTICE,"postgis_gist_sel: finished, returning with %lf",myest);
PG_RETURN_FLOAT8(myest);
}
static void
genericcostestimate2(Query *root, RelOptInfo *rel,
IndexOptInfo *index, List *indexQuals,
Cost *indexStartupCost,
Cost *indexTotalCost,
Selectivity *indexSelectivity,
double *indexCorrelation)
{
double numIndexTuples;
double numIndexPages;
List *selectivityQuals = indexQuals;
#if USE_VERSION >= 74
QualCost index_qual_cost;
#endif
//elog(NOTICE,"in genericcostestimate");
/*
* If the index is partial, AND the index predicate with the
* explicitly given indexquals to produce a more accurate idea of the
* index restriction. This may produce redundant clauses, which we
* hope that cnfify and clauselist_selectivity will deal with
* intelligently.
*
* Note that index->indpred and indexQuals are both in implicit-AND form
* to start with, which we have to make explicit to hand to
* canonicalize_qual, and then we get back implicit-AND form again.
*/
if (index->indpred != NIL)
{
Expr *andedQuals;
andedQuals = make_ands_explicit(nconc(listCopy(index->indpred),
indexQuals));
selectivityQuals = canonicalize_qual(andedQuals, true);
}
/* Estimate the fraction of main-table tuples that will be visited */
*indexSelectivity = clauselist_selectivity(root, selectivityQuals,
#if USE_VERSION < 74
lfirsti(rel->relids));
#else
rel->relid, JOIN_INNER);
#endif
/*
* Estimate the number of tuples that will be visited. We do it in
* this rather peculiar-looking way in order to get the right answer
* for partial indexes. We can bound the number of tuples by the
* index size, in any case.
*/
numIndexTuples = *indexSelectivity * rel->tuples;
//elog(NOTICE,"relation has %li pages",rel->pages);
//elog(NOTICE,"indexselectivity is %lf, ntuples = %lf, numindexTuples = %lf, index->tuples = %lf",*indexSelectivity, rel->tuples, numIndexTuples,index->tuples);
if (numIndexTuples > index->tuples)
numIndexTuples = index->tuples;
/*
* Always estimate at least one tuple is touched, even when
* indexSelectivity estimate is tiny.
*/
if (numIndexTuples < 1.0)
numIndexTuples = 1.0;
/*
* Estimate the number of index pages that will be retrieved.
*
* For all currently-supported index types, the first page of the index
* is a metadata page, and we should figure on fetching that plus a
* pro-rated fraction of the remaining pages.
*/
//elog(NOTICE,"index->pages = %li ",index->pages);
if (index->pages > 1 && index->tuples > 0)
{
numIndexPages = (numIndexTuples / index->tuples) * (index->pages - 1);
numIndexPages += 1; /* count the metapage too */
numIndexPages = ceil(numIndexPages);
}
else
numIndexPages = 1.0;
//elog(NOTICE,"numIndexPages = %lf ",numIndexPages);
/*
* Compute the index access cost.
*
* Our generic assumption is that the index pages will be read
* sequentially, so they have cost 1.0 each, not random_page_cost.
* Also, we charge for evaluation of the indexquals at each index
* tuple. All the costs are assumed to be paid incrementally during
* the scan.
*/
#if USE_VERSION < 74
*indexStartupCost = 0;
*indexTotalCost = numIndexPages +
(cpu_index_tuple_cost + cost_qual_eval(indexQuals)) *
numIndexTuples;
#else
cost_qual_eval(&index_qual_cost, indexQuals);
*indexStartupCost = index_qual_cost.startup;
*indexTotalCost = numIndexPages +
(cpu_index_tuple_cost + index_qual_cost.per_tuple) *
numIndexTuples;
#endif
//elog(NOTICE,"cpu_index_tuple_cost = %lf, cost_qual_eval(indexQuals)) = %lf",
// cpu_index_tuple_cost,cost_qual_eval(indexQuals));
//elog(NOTICE,"indexTotalCost = %lf ",*indexTotalCost);
/*
* Generic assumption about index correlation: there isn't any.
*/
*indexCorrelation = 0.97;
//elog(NOTICE,"indexcorrelation = %lf ",*indexCorrelation);
}
PG_FUNCTION_INFO_V1(postgisgistcostestimate);
Datum
postgisgistcostestimate(PG_FUNCTION_ARGS)
{
Query *root = (Query *) PG_GETARG_POINTER(0);
RelOptInfo *rel = (RelOptInfo *) PG_GETARG_POINTER(1);
IndexOptInfo *index = (IndexOptInfo *) PG_GETARG_POINTER(2);
List *indexQuals = (List *) PG_GETARG_POINTER(3);
Cost *indexStartupCost = (Cost *) PG_GETARG_POINTER(4);
Cost *indexTotalCost = (Cost *) PG_GETARG_POINTER(5);
Selectivity *indexSelectivity = (Selectivity *) PG_GETARG_POINTER(6);
double *indexCorrelation = (double *) PG_GETARG_POINTER(7);
//elog(NOTICE,"postgisgistcostestimate was called");
genericcostestimate2(root, rel, index, indexQuals,
indexStartupCost, indexTotalCost,
indexSelectivity, indexCorrelation);
//elog(NOTICE,"postgisgistcostestimate is going to return void");
PG_RETURN_VOID();
}
postgis-0.8.1/postgis_fn.c 0100664 0000773 0000144 00000222171 07754140343 015161 0 ustar postgis users
/**********************************************************************
* $Id: postgis_fn.c,v 1.31 2025/11/11 10:58:43 strk Exp $
*
* PostGIS - Spatial Types for PostgreSQL
* http://postgis.refractions.net
* Copyright 2001-2003 Refractions Research Inc.
*
* This is free software; you can redistribute and/or modify it under
* the terms of hte GNU General Public Licence. See the COPYING file.
*
**********************************************************************
* $Log: postgis_fn.c,v $
* Revision 1.31 2025/11/11 10:58:43 strk
* Fixed a typo in envelope()
*
* Revision 1.30 2025/10/29 15:53:10 strk
* geoscentroid() removed. both geos and pgis versions are called 'centroid'.
* only one version will be compiled based on USE_GEOS flag.
*
* Revision 1.29 2025/10/28 16:57:35 strk
* Added collect_garray() function.
*
* Revision 1.28 2025/10/28 15:16:17 strk
* unite_sfunc() from postgis_geos.c renamed to geom_accum() and moved in postgis_fn.c
*
* Revision 1.27 2025/10/17 16:12:23 dblasby
* Made Envelope() CW instead of CCW.
*
* Revision 1.26 2025/10/17 16:07:05 dblasby
* made isEmpty() return true/false
*
* Revision 1.25 2025/09/16 20:27:12 dblasby
* added ability to delete geometries.
*
* Revision 1.24 2025/08/08 18:19:20 dblasby
* Conformance changes.
* Removed junk from postgis_debug.c and added the first run of the long
* transaction locking support. (this will change - dont use it)
* conformance tests were corrected
* some dos cr/lf removed
* empty geometries i.e. GEOMETRYCOLLECT(EMPTY) added (with indexing support)
* pointN(,1) now returns the first point (used to return 2nd)
*
* Revision 1.23 2025/07/25 17:08:37 pramsey
* Moved Cygwin endian define out of source files into postgis.h common
* header file.
*
* Revision 1.22 2025/07/01 18:30:55 pramsey
* Added CVS revision headers.
*
*
**********************************************************************/
#include "postgres.h"
#include
#include
#include
#include
#include
#include "access/gist.h"
#include "access/itup.h"
#include "access/rtree.h"
#include "fmgr.h"
#include "postgis.h"
#include "utils/elog.h"
#include "utils/array.h"
#define NfunctionFirstPoint 1
// if you use #define NfunctionFirstPoint 0, you get 0-based indexing (this is what programmers want)::
// pointN(, 0) is the 1st point, and pointN(, 1) is the second point.
// if you use #define NfunctionFirstPoint 1, you get 1-based indexing (which seems to be what the spec wants)::
// pointN(, 1) is the 1st point, and pointN(, 2) is the second point.
#define SHOW_DIGS_DOUBLE 15
#define MAX_DIGS_DOUBLE (SHOW_DIGS_DOUBLE + 6 + 1 + 3 +1)
// #define DEBUG_GIST
//#define DEBUG_GIST2
/**************************************************************************
* GENERAL PURPOSE GEOMETRY FUNCTIONS
**************************************************************************/
double line_length2d(LINE3D *line)
{
int i;
POINT3D *frm,*to;
double dist = 0.0;
if (line->npoints <2)
return 0.0; //must have >1 point to make sense
frm = &line->points[0];
for (i=1; inpoints;i++)
{
to = &line->points[i];
dist += sqrt( ( (frm->x - to->x)*(frm->x - to->x) ) +
( (frm->y - to->y)*(frm->y - to->y) ) );
frm = to;
}
return dist;
}
double line_length3d(LINE3D *line)
{
int i;
POINT3D *frm,*to;
double dist = 0.0;
if (line->npoints <2)
return 0.0; //must have >1 point to make sense
frm = &line->points[0];
for (i=1; inpoints;i++)
{
to = &line->points[i];
dist += sqrt( ( (frm->x - to->x)*(frm->x - to->x) ) +
((frm->y - to->y)*(frm->y - to->y) ) +
((frm->z - to->z)*(frm->z - to->z) ) );
frm = to;
}
return dist;
}
//find the "length of a geometry"
// length3d(point) = 0
// length3d(line) = length of line
// length3d(polygon) = 0 -- could make sense to return sum(ring perimeter)
// uses euclidian 3d length
PG_FUNCTION_INFO_V1(length3d);
Datum length3d(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
int32 *offsets1;
char *o1;
int32 type1,j;
LINE3D *line;
double dist = 0.0;
offsets1 = (int32 *) ( ((char *) &(geom1->objType[0] ))+ sizeof(int32) * geom1->nobjs ) ;
//now have to do a scan of each object
for (j=0; j< geom1->nobjs; j++) //for each object in geom1
{
o1 = (char *) geom1 +offsets1[j] ;
type1= geom1->objType[j];
if (type1 == LINETYPE) //LINESTRING
{
line = (LINE3D *) o1;
dist += line_length3d(line);
}
}
PG_RETURN_FLOAT8(dist);
}
//find the "length of a geometry"
// length3d(point) = 0
// length3d(line) = length of line
// length3d(polygon) = 0 -- could make sense to return sum(ring perimeter)
// uses euclidian 2d length
PG_FUNCTION_INFO_V1(length2d);
Datum length2d(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
int32 *offsets1;
char *o1;
int32 type1,j;
LINE3D *line;
double dist = 0.0;
offsets1 = (int32 *) ( ((char *) &(geom1->objType[0] ))+ sizeof(int32) * geom1->nobjs ) ;
//now have to do a scan of each object
for (j=0; j< geom1->nobjs; j++) //for each object in geom1
{
o1 = (char *) geom1 +offsets1[j] ;
type1= geom1->objType[j];
if (type1 == LINETYPE) //LINESTRING
{
line = (LINE3D *) o1;
dist += line_length2d(line);
}
}
PG_RETURN_FLOAT8(dist);
}
//find the 2d area of the outer ring - sum (area 2d of inner rings)
// Could use a more numerically stable calculator...
double polygon_area2d_old(POLYGON3D *poly1)
{
double poly_area=0.0, ringarea=0.0;
int i,j,ring,pt_offset;
POINT3D *pts1;
pts1 = (POINT3D *) ( (char *)&(poly1->npoints[poly1->nrings] ) );
pts1 = (POINT3D *) MAXALIGN(pts1);
//elog(NOTICE,"in polygon_area2d_old");
pt_offset = 0; //index to first point in ring
for (ring = 0; ring < poly1->nrings; ring++)
{
ringarea = 0.0;
for (i=0;i<(poly1->npoints[ring]-1);i++)
{
// j = (i+1) % (poly1->npoints[ring]);
j = i+1;
ringarea += pts1[pt_offset+ i].x * pts1[pt_offset+j].y - pts1[pt_offset+ i].y * pts1[pt_offset+j].x;
}
ringarea /= 2.0;
//elog(NOTICE," ring 1 has area %lf",ringarea);
ringarea = fabs(ringarea );
if (ring != 0) //outer
ringarea = -1.0*ringarea ; // its a hole
poly_area += ringarea;
pt_offset += poly1->npoints[ring];
}
return poly_area;
}
//calculate the area of all the subobj in a polygon
// area(point) = 0
// area (line) = 0
// area(polygon) = find its 2d area
PG_FUNCTION_INFO_V1(area2d);
Datum area2d(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
int32 *offsets1;
char *o1;
int32 type1,j;
POLYGON3D *poly;
double area = 0.0;
offsets1 = (int32 *) ( ((char *) &(geom1->objType[0] ))+ sizeof(int32) * geom1->nobjs ) ;
//now have to do a scan of each object
for (j=0; j< geom1->nobjs; j++) //for each object in geom1
{
o1 = (char *) geom1 +offsets1[j] ;
type1= geom1->objType[j];
if (type1 == POLYGONTYPE) //POLYGON
{
poly = (POLYGON3D *) o1;
area += polygon_area2d_old(poly);
}
}
PG_RETURN_FLOAT8(area);
}
double polygon_perimeter3d(POLYGON3D *poly1)
{
double poly_perimeter=0.0, ring_perimeter=0.0;
int i,ring,pt_offset;
POINT3D *pts1;
POINT3D *to,*frm;
pts1 = (POINT3D *) ( (char *)&(poly1->npoints[poly1->nrings] ) );
pts1 = (POINT3D *) MAXALIGN(pts1);
pt_offset = 0; //index to first point in ring
for (ring = 0; ring < poly1->nrings; ring++)
{
ring_perimeter = 0.0;
frm = &pts1[pt_offset];
for (i=1; inpoints[ring];i++)
{
to = &pts1[pt_offset+ i];
ring_perimeter += sqrt( ( (frm->x - to->x)*(frm->x - to->x) ) +
((frm->y - to->y)*(frm->y - to->y) ) +
((frm->z - to->z)*(frm->z - to->z) ) );
frm = to;
}
poly_perimeter += ring_perimeter;
pt_offset += poly1->npoints[ring];
}
return poly_perimeter;
}
double polygon_perimeter2d(POLYGON3D *poly1)
{
double poly_perimeter=0.0, ring_perimeter=0.0;
int i,ring,pt_offset;
POINT3D *pts1;
POINT3D *to,*frm;
pts1 = (POINT3D *) ( (char *)&(poly1->npoints[poly1->nrings] ) );
pts1 = (POINT3D *) MAXALIGN(pts1);
pt_offset = 0; //index to first point in ring
for (ring = 0; ring < poly1->nrings; ring++)
{
ring_perimeter = 0.0;
frm = &pts1[pt_offset];
for (i=1; inpoints[ring];i++)
{
to = &pts1[pt_offset+ i];
ring_perimeter += sqrt( ( (frm->x - to->x)*(frm->x - to->x) ) +
((frm->y - to->y)*(frm->y - to->y) ) );
frm = to;
}
poly_perimeter += ring_perimeter;
pt_offset += poly1->npoints[ring];
}
return poly_perimeter;
}
//calculate the perimeter of polys (sum of length of all rings)
PG_FUNCTION_INFO_V1(perimeter3d);
Datum perimeter3d(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
int32 *offsets1;
char *o1;
int32 type1,j;
POLYGON3D *poly;
double area = 0.0;
offsets1 = (int32 *) ( ((char *) &(geom1->objType[0] ))+ sizeof(int32) * geom1->nobjs ) ;
//now have to do a scan of each object
for (j=0; j< geom1->nobjs; j++) //for each object in geom1
{
o1 = (char *) geom1 +offsets1[j] ;
type1= geom1->objType[j];
if (type1 == POLYGONTYPE) //POLYGON
{
poly = (POLYGON3D *) o1;
area += polygon_perimeter3d(poly);
}
}
PG_RETURN_FLOAT8(area);
}
//calculate the perimeter of polys (sum of length of all rings)
PG_FUNCTION_INFO_V1(perimeter2d);
Datum perimeter2d(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
int32 *offsets1;
char *o1;
int32 type1,j;
POLYGON3D *poly;
double area = 0.0;
offsets1 = (int32 *) ( ((char *) &(geom1->objType[0] ))+ sizeof(int32) * geom1->nobjs ) ;
//now have to do a scan of each object
for (j=0; j< geom1->nobjs; j++) //for each object in geom1
{
o1 = (char *) geom1 +offsets1[j] ;
type1= geom1->objType[j];
if (type1 == POLYGONTYPE) //POLYGON
{
poly = (POLYGON3D *) o1;
area += polygon_perimeter2d(poly);
}
}
PG_RETURN_FLOAT8(area);
}
// cn_PnPoly(): crossing number test for a point in a polygon
// input: P = a point,
// V[] = vertex points of a polygon V[n+1] with V[n]=V[0]
// returns: 0 = outside, 1 = inside
//
// Our polygons have first and last point the same,
//
int PIP( POINT3D *P, POINT3D *V, int n )
{
int cn = 0; // the crossing number counter
int i;
double vt;
// loop through all edges of the polygon
for (i=0; i< (n-1) ; i++)
{ // edge from V[i] to V[i+1]
if (((V[i].y <= P->y) && (V[i+1].y > P->y)) // an upward crossing
|| ((V[i].y > P->y) && (V[i+1].y <= P->y))) // a downward crossing
{
vt = (double)(P->y - V[i].y) / (V[i+1].y - V[i].y);
if (P->x < V[i].x + vt * (V[i+1].x - V[i].x)) // P.x x >= box->LLB.x) && (point->x <= box->URT.x) &&
(point->y >= box->LLB.y) && (point->y <= box->URT.y)
);
}
// see if a linestring is inside a box - check to see if each its line
// segments are inside the box
// NOTE: all this is happening in 2d - third dimention is ignored
//
//use a modified CohenSutherland line clipping algoritm
//
//Step one - compute outcodes for Pi and Pi+1
//
//
// | |
// 1001 | 1000 | 1010
// | |
// ----------+-----------+------------
// | (inside) |
// 0001 | | 0010
// | 0000 |
// ----------+-----------+------------
// | |
// 0101 | 0100 | 0110
// | |
//
// If Pi or Pi+1 have code 0000 then this line seg is inside the box (trivial accept)
// if Pi && Pi+1 != 0 then seg is NOT in the box (trivial reject)
//
// Otherwise the line seg might traverse through the box.
// => see if the seg intersects any of the walls of the box.
//
int compute_outcode( POINT3D *p, BOX3D *box)
{
int Code=0;
//printf("compute outcode:\n");
//print_box(box);
//printf("point = [%g,%g]\n",p->x,p->y);
if (p->y > box->URT.y )
Code = 8;
else
{
if (p->y LLB.y )
{
Code = 4;
}
}
if (p->x > box->URT.x )
{
return (Code+2);
}
if (p->x LLB.x )
{
return (Code+1);
}
return (Code);
}
bool lineseg_inside_box( POINT3D *P1, POINT3D *P2, BOX3D *box)
{
int outcode_p1, outcode_p2;
double Ax,Ay, Bx,By, Cx,Cy, Dx,Dy;
double r,s;
outcode_p1 = compute_outcode(P1, box);
if (outcode_p1 ==0)
return TRUE;
outcode_p2 = compute_outcode(P2, box);
if (outcode_p2 ==0)
return TRUE;
if ((outcode_p1 & outcode_p2) != 0)
return FALSE;
if ((outcode_p1 + outcode_p2) == 12)
return TRUE; //vertically slices box
if ((outcode_p1 + outcode_p2) == 3)
return TRUE; //horizontally slices box
//printf("have to do boundry calcs\n");
// know that its a diagonal line
//this is the tough case - it may or maynot intersect the box
//see if it intersects the horizonal and vertical box lines
// from comp.graphics.algo's faq:
/*
(Ay-Cy)(Dx-Cx)-(Ax-Cx)(Dy-Cy)
r = ------------------------------------
(Bx-Ax)(Dy-Cy)-(By-Ay)(Dx-Cx)
(Ay-Cy)(Bx-Ax)-(Ax-Cx)(By-Ay)
s = -----------------------------------
(Bx-Ax)(Dy-Cy)-(By-Ay)(Dx-Cx)
*/
// if 0<= r&s <=1 then intersection exists
Ax = P1->x; Ay = P1->y;
Bx = P2->x; By = P2->y;
//top hor part of box
Cx = box->LLB.x; Cy= box->URT.y;
Dx = box->URT.x; Dy= box->URT.y;
r= ((Ay-Cy)*(Dx-Cx)-(Ax-Cx)*(Dy-Cy) )/
((Bx-Ax)*(Dy-Cy)-(By-Ay)*(Dx-Cx) ) ;
s= ((Ay-Cy)*(Bx-Ax)-(Ax-Cx)*(By-Ay))/
((Bx-Ax)*(Dy-Cy)-(By-Ay)*(Dx-Cx) ) ;
if ( (r>=0) && (r<=1) && (s>=0) && (s<=1) )
return TRUE;
//bottom hor part of box
Cx = box->LLB.x; Cy= box->LLB.y;
Dx = box->URT.x; Dy= box->LLB.y;
r= ((Ay-Cy)*(Dx-Cx)-(Ax-Cx)*(Dy-Cy) )/
((Bx-Ax)*(Dy-Cy)-(By-Ay)*(Dx-Cx) ) ;
s= ((Ay-Cy)*(Bx-Ax)-(Ax-Cx)*(By-Ay))/
((Bx-Ax)*(Dy-Cy)-(By-Ay)*(Dx-Cx) ) ;
if ( (r>=0) && (r<=1) && (s>=0) && (s<=1) )
return TRUE;
//left ver part of box
Cx = box->LLB.x; Cy= box->LLB.y;
Dx = box->LLB.x; Dy= box->URT.y;
r= ((Ay-Cy)*(Dx-Cx)-(Ax-Cx)*(Dy-Cy) )/
((Bx-Ax)*(Dy-Cy)-(By-Ay)*(Dx-Cx) ) ;
s= ((Ay-Cy)*(Bx-Ax)-(Ax-Cx)*(By-Ay))/
((Bx-Ax)*(Dy-Cy)-(By-Ay)*(Dx-Cx) ) ;
if ( (r>=0) && (r<=1) && (s>=0) && (s<=1) )
return TRUE;
//right ver part of box
Cx = box->URT.x; Cy= box->LLB.y;
Dx = box->URT.x; Dy= box->URT.y;
r= ((Ay-Cy)*(Dx-Cx)-(Ax-Cx)*(Dy-Cy) )/
((Bx-Ax)*(Dy-Cy)-(By-Ay)*(Dx-Cx) ) ;
s= ((Ay-Cy)*(Bx-Ax)-(Ax-Cx)*(By-Ay))/
((Bx-Ax)*(Dy-Cy)-(By-Ay)*(Dx-Cx) ) ;
if ( (r>=0) && (r<=1) && (s>=0) && (s<=1) )
return TRUE;
//otherwise we did not intersect the box
return FALSE;
}
//give the work to an easier process
bool linestring_inside_box(POINT3D *pts, int npoints, BOX3D *box)
{
POINT3D *frm,*to;
int i;
if (npoints <2)
return FALSE; //must have >1 point to make sense
frm = &pts[0];
for (i=1; i< npoints;i++)
{
to = &pts[i];
if (lineseg_inside_box( frm, to, box))
return TRUE;
frm = to;
}
return FALSE;
}
//this ones the most complex
// 1. treat the outer ring as a line and see if its inside
// + if it is, then poly is inside box
// 2. The polygon could be completely contained inside the box
// + line detector (step 1) would have found this
// 3. The polygon could be completely surrounding the box
// + point-in-polygon of one of the box corners
// + COMPLEXITY: box could be totally inside a single hole
// +test all holes like step 1. Any that pass arent "bad" holes
// + each of the bad holes do a point-in-polygon if true =-> totally in hole
bool polygon_truely_inside(POLYGON3D *poly, BOX3D *box)
{
bool outer_ring_inside,outer_ring_surrounds;
POINT3D *pts1;
POINT3D test_point;
int32 ring;
int point_offset;
pts1 = (POINT3D *) ( (char *)&(poly->npoints[poly->nrings] ) );
pts1 = (POINT3D *) MAXALIGN(pts1);
//step 1 (and 2)
outer_ring_inside = linestring_inside_box(pts1, poly->npoints[0], box);
if (outer_ring_inside)
return TRUE;
test_point.x = box->LLB.x;
test_point.y = box->LLB.y;
//.z unimportant
outer_ring_surrounds = PIP(&test_point, pts1,poly->npoints[0] );
if (!(outer_ring_surrounds))
return FALSE; // disjoing
//printf("polygon - have to check holes\n");
//step 3
point_offset = poly->npoints[0];
for (ring =1; ring< poly->nrings; ring ++)
{
if (!( linestring_inside_box(&pts1[point_offset], poly->npoints[ring], box) ))
{
//doesnt intersect the box
// so if one of the corners of the box is inside the hole, it totally
// surrounds the box
if (PIP(&test_point, &pts1[point_offset],poly->npoints[ring] ) )
return FALSE;
}
point_offset += poly->npoints[ring];
}
return TRUE;
}
//This is more complicated because all the points in the line can be outside the box,
// but one of the edges can cross into the box.
// We send the work off to another function because its generically usefull for
// polygons too
bool line_truely_inside( LINE3D *line, BOX3D *box)
{
return linestring_inside_box(&line->points[0], line->npoints, box);
}
//is anything in geom1 really inside the the bvol (2d only) defined in geom2?
// send each object to its proper handler
PG_FUNCTION_INFO_V1(truly_inside);
Datum truly_inside(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
GEOMETRY *geom2 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
BOX3D *the_bbox;
int32 *offsets1;
char *o1;
int32 type1,j;
POLYGON3D *poly;
LINE3D *line;
POINT3D *point;
if (geom1->SRID != geom2->SRID)
{
elog(ERROR,"Operation on two GEOMETRIES with different SRIDs\n");
PG_RETURN_NULL();
}
the_bbox = &geom2->bvol;
offsets1 = (int32 *) ( ((char *) &(geom1->objType[0] ))+ sizeof(int32) * geom1->nobjs ) ;
//now have to do a scan of each object
for (j=0; j< geom1->nobjs; j++) //for each object in geom1
{
o1 = (char *) geom1 +offsets1[j] ;
type1= geom1->objType[j];
if (type1 == POINTTYPE) //point
{
point = (POINT3D *) o1;
if ( point_truely_inside(point, the_bbox))
PG_RETURN_BOOL(TRUE);
}
if (type1 == LINETYPE) //line
{
line = (LINE3D *) o1;
if ( line_truely_inside(line, the_bbox))
PG_RETURN_BOOL(TRUE);
}
if (type1 == POLYGONTYPE) //POLYGON
{
poly = (POLYGON3D *) o1;
if ( polygon_truely_inside(poly, the_bbox))
PG_RETURN_BOOL(TRUE);
}
}
PG_RETURN_BOOL(FALSE);
}
//number of points in an object
PG_FUNCTION_INFO_V1(npoints);
Datum npoints(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
int32 *offsets1;
char *o1;
int32 type1,j,i;
POLYGON3D *poly;
LINE3D *line;
int32 numb_points = 0;
offsets1 = (int32 *) ( ((char *) &(geom1->objType[0] ))+ sizeof(int32) * geom1->nobjs ) ;
//now have to do a scan of each object
for (j=0; j< geom1->nobjs; j++) //for each object in geom1
{
o1 = (char *) geom1 +offsets1[j] ;
type1= geom1->objType[j];
if (type1 == POINTTYPE) //point
{
numb_points ++;
}
if (type1 == LINETYPE) //line
{
line = (LINE3D *) o1;
numb_points += line->npoints;
}
if (type1 == POLYGONTYPE) //POLYGON
{
poly = (POLYGON3D *) o1;
for (i=0; inrings;i++)
{
numb_points += poly->npoints[i];
}
}
}
PG_RETURN_INT32(numb_points);
}
//number of rings in an object
PG_FUNCTION_INFO_V1(nrings);
Datum nrings(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
int32 *offsets1;
char *o1;
int32 type1,j;
POLYGON3D *poly;
int32 numb_rings = 0;
offsets1 = (int32 *) ( ((char *) &(geom1->objType[0] ))+ sizeof(int32) * geom1->nobjs ) ;
//now have to do a scan of each object
for (j=0; j< geom1->nobjs; j++) //for each object in geom1
{
o1 = (char *) geom1 +offsets1[j] ;
type1= geom1->objType[j];
if (type1 == POLYGONTYPE) //POLYGON
{
poly = (POLYGON3D *) o1;
numb_rings += poly->nrings;
}
}
PG_RETURN_INT32(numb_rings);
}
void translate_points(POINT3D *pt, int npoints,double x_off, double y_off, double z_off)
{
int i;
//printf("translating %i points by [%g,%g,%g]\n",npoints,x_off,y_off,z_off);
if (npoints <1)
return; //nothing to do
for (i=0;isize);
memcpy(geom1, geom, geom->size); //Will handle SRID and grid
offsets1 = (int32 *) ( ((char *) &(geom1->objType[0] ))+ sizeof(int32) * geom1->nobjs ) ;
//now have to do a scan of each object
for (j=0; j< geom1->nobjs; j++) //for each object in geom1
{
o1 = (char *) geom1 +offsets1[j] ;
type= geom1->objType[j];
if (type == POINTTYPE) //point
{
point = (POINT3D *) o1;
translate_points(point, 1,x_off,y_off,z_off);
}
if (type == LINETYPE) //line
{
line = (LINE3D *) o1;
translate_points(&(line->points[0]), line->npoints,x_off,y_off,z_off);
}
if (type == POLYGONTYPE) //POLYGON
{
poly = (POLYGON3D *) o1;
//find where the points are and where to put them
numb_points =0;
for (i=0; inrings;i++)
{
numb_points += poly->npoints[i];
}
pts = (POINT3D *) ( (char *)&(poly->npoints[poly->nrings] ) );
pts = (POINT3D *) MAXALIGN(pts);
translate_points(pts, numb_points,x_off,y_off,z_off);
}
}
//translate the bounding box as well
geom1->bvol.LLB.x += x_off;
geom1->bvol.LLB.y += y_off;
geom1->bvol.LLB.z += z_off;
geom1->bvol.URT.x += x_off;
geom1->bvol.URT.y += y_off;
geom1->bvol.URT.z += z_off;
PG_RETURN_POINTER(geom1);
}
// set the is3d flag so the system think the geometry is 2d or 3d
PG_FUNCTION_INFO_V1(force_2d);
Datum force_2d(PG_FUNCTION_ARGS)
{
GEOMETRY *geom = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
GEOMETRY *result;
result = (GEOMETRY *) palloc(geom->size);
memcpy(result,geom, geom->size);
result->is3d = FALSE;
PG_RETURN_POINTER(result);
}
PG_FUNCTION_INFO_V1(force_3d);
Datum force_3d(PG_FUNCTION_ARGS)
{
GEOMETRY *geom = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
GEOMETRY *result;
result = (GEOMETRY *) palloc(geom->size);
memcpy(result,geom, geom->size);
result->is3d = TRUE;
PG_RETURN_POINTER(result);
}
//NULL safe bbox union
// combine_bbox(BOX3D, geometry) => union BOX3D and geometry->bvol
// For finding the extent of a set of rows using the extent() aggregate
PG_FUNCTION_INFO_V1(combine_bbox);
Datum combine_bbox(PG_FUNCTION_ARGS)
{
Pointer box3d_ptr = PG_GETARG_POINTER(0);
Pointer geom_ptr = PG_GETARG_POINTER(1);
BOX3D *a,*b;
GEOMETRY *geom;
BOX3D *box;
if ( (box3d_ptr == NULL) && (geom_ptr == NULL) )
{
PG_RETURN_NULL(); // combine_bbox(null,null) => null
}
if (box3d_ptr == NULL)
{
geom = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
box = (BOX3D *) palloc(sizeof(BOX3D));
memcpy(box, &(geom->bvol), sizeof(BOX3D) );
PG_RETURN_POINTER(box); // combine_bbox(null, geometry) => geometry->bvol
}
if (geom_ptr == NULL)
{
box = (BOX3D *) palloc(sizeof(BOX3D));
memcpy(box, (char *) PG_GETARG_DATUM(0) , sizeof(BOX3D) );
PG_RETURN_POINTER( box ); // combine_bbox(BOX3D, null) => BOX3D
}
//combine_bbox(BOX3D, geometry) => union(BOX3D, geometry->bvol)
box = (BOX3D *) palloc(sizeof(BOX3D));
a = (BOX3D *) PG_GETARG_DATUM(0) ;
b= &(( (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1)) )->bvol);
box->LLB.x = b->LLB.x;
box->LLB.y = b->LLB.y;
box->LLB.z = b->LLB.z;
box->URT.x = b->URT.x;
box->URT.y = b->URT.y;
box->URT.z = b->URT.z;
if (a->LLB.x < b->LLB.x)
box->LLB.x = a->LLB.x;
if (a->LLB.y < b->LLB.y)
box->LLB.y = a->LLB.y;
if (a->LLB.z < b->LLB.z)
box->LLB.z = a->LLB.z;
if (a->URT.x > b->URT.x)
box->URT.x = a->URT.x;
if (a->URT.y > b->URT.y)
box->URT.y = a->URT.y;
if (a->URT.z > b->URT.z)
box->URT.z = a->URT.z;
PG_RETURN_POINTER( box );
}
//return 2 for 2d geometries or 3 for 3d geometries
PG_FUNCTION_INFO_V1(dimension);
Datum dimension(PG_FUNCTION_ARGS)
{
GEOMETRY *geom = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
int t;
int result,dim,type;
if ((geom->type == COLLECTIONTYPE) && (geom->nobjs ==0))
PG_RETURN_INT32(-1);
if (geom->type == POINTTYPE)
PG_RETURN_INT32(0);
if (geom->type == LINETYPE)
PG_RETURN_INT32(1);
if (geom->type == POLYGONTYPE)
PG_RETURN_INT32(2);
if (geom->type == MULTIPOINTTYPE)
PG_RETURN_INT32(0);
if (geom->type == MULTILINETYPE)
PG_RETURN_INT32(1);
if (geom->type == MULTIPOLYGONTYPE)
PG_RETURN_INT32(2);
result = -1;
dim =0;
//its a collection -look for the largest one
for (t=0;tnobjs;t++)
{
type= geom->objType[t];
if (type == POINTTYPE)
dim=0;
if (type == LINETYPE)
dim=1;
if (type == POLYGONTYPE)
dim=2;
if (dim>result)
result = dim;
}
PG_RETURN_INT32(result);
}
//returns a string representation of this geometry's type
PG_FUNCTION_INFO_V1(geometrytype);
Datum geometrytype(PG_FUNCTION_ARGS)
{
GEOMETRY *geom = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
char *text_ob = palloc(20+4);
char *result = text_ob+4;
int32 size;
memset(result,0,20);
if (geom->type == POINTTYPE)
strcpy(result,"POINT");
if (geom->type == MULTIPOINTTYPE)
strcpy(result,"MULTIPOINT");
if (geom->type == LINETYPE)
strcpy(result,"LINESTRING");
if (geom->type == MULTILINETYPE)
strcpy(result,"MULTILINESTRING");
if (geom->type == POLYGONTYPE)
strcpy(result,"POLYGON");
if (geom->type == MULTIPOLYGONTYPE)
strcpy(result,"MULTIPOLYGON");
if (geom->type == COLLECTIONTYPE)
strcpy(result,"GEOMETRYCOLLECTION");
if (strlen(result) == 0)
strcpy(result,"UNKNOWN");
size = strlen(result) +4 ;
memcpy(text_ob, &size,4); // size of string
PG_RETURN_POINTER(text_ob);
}
//makes a polygon of a features bvol - 1st point = LL 3rd=UR
// 2d only
//
// create new geometry of type polygon, 1 ring, 5 points
PG_FUNCTION_INFO_V1(envelope);
Datum envelope(PG_FUNCTION_ARGS)
{
GEOMETRY *geom = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
GEOMETRY *result;
POLYGON3D *poly;
POINT3D pts[5]; //5 points around box
int pts_per_ring[1];
int poly_size;
//use LLB's z value (we're going to set is3d to false)
//0,1,2,3,4 --> CCW order, 4,3,2,1,0 --> CW order
set_point( &pts[4], geom->bvol.LLB.x , geom->bvol.LLB.y , geom->bvol.LLB.z );
set_point( &pts[3], geom->bvol.URT.x , geom->bvol.LLB.y , geom->bvol.LLB.z );
set_point( &pts[2], geom->bvol.URT.x , geom->bvol.URT.y , geom->bvol.LLB.z );
set_point( &pts[1], geom->bvol.LLB.x , geom->bvol.URT.y , geom->bvol.LLB.z );
set_point( &pts[0], geom->bvol.LLB.x , geom->bvol.LLB.y , geom->bvol.LLB.z );
pts_per_ring[0] = 5; //ring has 5 points
//make a polygon
poly = make_polygon(1, pts_per_ring, pts, 5, &poly_size);
result = make_oneobj_geometry(poly_size, (char *)poly, POLYGONTYPE, FALSE,geom->SRID, geom->scale, geom->offsetX, geom->offsetY);
PG_RETURN_POINTER(result);
}
//X(GEOMETRY) -- find the first POINT(..) in GEOMETRY, returns its X value.
//Return NULL if there is no POINT(..) in GEOMETRY
PG_FUNCTION_INFO_V1(x_point);
Datum x_point(PG_FUNCTION_ARGS)
{
GEOMETRY *geom = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
char *o;
int type1,j;
int32 *offsets1;
offsets1 = (int32 *) ( ((char *) &(geom->objType[0] ))+ sizeof(int32) * geom->nobjs ) ;
//now have to do a scan of each object
for (j=0; j< geom->nobjs; j++) //for each object in geom1
{
o = (char *) geom +offsets1[j] ;
type1= geom->objType[j];
if (type1 == POINTTYPE) //point
{
PG_RETURN_FLOAT8( ((POINT3D *)o)->x) ;
}
}
PG_RETURN_NULL();
}
//Y(GEOMETRY) -- find the first POINT(..) in GEOMETRY, returns its Y value.
//Return NULL if there is no POINT(..) in GEOMETRY
PG_FUNCTION_INFO_V1(y_point);
Datum y_point(PG_FUNCTION_ARGS)
{
GEOMETRY *geom = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
char *o;
int type1,j;
int32 *offsets1;
offsets1 = (int32 *) ( ((char *) &(geom->objType[0] ))+ sizeof(int32) * geom->nobjs ) ;
//now have to do a scan of each object
for (j=0; j< geom->nobjs; j++) //for each object in geom1
{
o = (char *) geom +offsets1[j] ;
type1= geom->objType[j];
if (type1 == POINTTYPE) //point
{
PG_RETURN_FLOAT8( ((POINT3D *)o)->y) ;
}
}
PG_RETURN_NULL();
}
//Z(GEOMETRY) -- find the first POINT(..) in GEOMETRY, returns its Z value.
//Return NULL if there is no POINT(..) in GEOMETRY
PG_FUNCTION_INFO_V1(z_point);
Datum z_point(PG_FUNCTION_ARGS)
{
GEOMETRY *geom = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
char *o;
int type1,j;
int32 *offsets1;
offsets1 = (int32 *) ( ((char *) &(geom->objType[0] ))+ sizeof(int32) * geom->nobjs ) ;
//now have to do a scan of each object
for (j=0; j< geom->nobjs; j++) //for each object in geom1
{
o = (char *) geom +offsets1[j] ;
type1= geom->objType[j];
if (type1 == POINTTYPE) //point
{
PG_RETURN_FLOAT8( ((POINT3D *)o)->z) ;
}
}
PG_RETURN_NULL();
}
//numpoints(GEOMETRY) -- find the first linestring in GEOMETRY, return
//the number of points in it. Return NULL if there is no LINESTRING(..)
//in GEOMETRY
PG_FUNCTION_INFO_V1(numpoints_linestring);
Datum numpoints_linestring(PG_FUNCTION_ARGS)
{
GEOMETRY *geom = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
char *o;
int type1,j;
int32 *offsets1;
offsets1 = (int32 *) ( ((char *) &(geom->objType[0] ))+ sizeof(int32) * geom->nobjs ) ;
for (j=0; j< geom->nobjs; j++) //for each object in geom1
{
o = (char *) geom +offsets1[j] ;
type1= geom->objType[j];
if (type1 == LINETYPE) //linestring
{
PG_RETURN_INT32( ((LINE3D *)o)->npoints) ;
}
}
PG_RETURN_NULL();
}
//pointn(GEOMETRY,INTEGER) -- find the first linestring in GEOMETRY,
//return the point at index INTEGER (0 is 1st point). Return NULL if
//there is no LINESTRING(..) in GEOMETRY or INTEGER is out of bounds.
// keeps is3d flag
PG_FUNCTION_INFO_V1(pointn_linestring);
Datum pointn_linestring(PG_FUNCTION_ARGS)
{
GEOMETRY *geom = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
int32 wanted_index =PG_GETARG_INT32(1);
char *o;
int type1,j;
int32 *offsets1;
LINE3D *line;
wanted_index -= NfunctionFirstPoint;
offsets1 = (int32 *) ( ((char *) &(geom->objType[0] ))+ sizeof(int32) * geom->nobjs ) ;
for (j=0; j< geom->nobjs; j++) //for each object in geom1
{
o = (char *) geom +offsets1[j] ;
type1= geom->objType[j];
if (type1 == LINETYPE) //linestring
{
line = (LINE3D *)o;
if ( (wanted_index<0) || (wanted_index> (line->npoints-1) ) )
PG_RETURN_NULL(); //index out of range
//get the point, make a new geometry
PG_RETURN_POINTER(
make_oneobj_geometry(sizeof(POINT3D),
(char *)&line->points[wanted_index],
POINTTYPE, geom->is3d, geom->SRID, geom->scale, geom->offsetX, geom->offsetY)
);
}
}
PG_RETURN_NULL();
}
// exteriorRing(GEOMETRY) -- find the first polygon in GEOMETRY, return
//its exterior ring (as a linestring). Return NULL if there is no
//POLYGON(..) in GEOMETRY.
PG_FUNCTION_INFO_V1(exteriorring_polygon);
Datum exteriorring_polygon(PG_FUNCTION_ARGS)
{
GEOMETRY *geom = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
char *o;
int type1,j;
int32 *offsets1;
LINE3D *line;
POLYGON3D *poly;
POINT3D *pts;
int size_line;
offsets1 = (int32 *) ( ((char *) &(geom->objType[0] ))+ sizeof(int32) * geom->nobjs ) ;
for (j=0; j< geom->nobjs; j++) //for each object in geom1
{
o = (char *) geom +offsets1[j] ;
type1= geom->objType[j];
if (type1 == POLYGONTYPE) //polygon object
{
poly = (POLYGON3D *)o;
pts = (POINT3D *) ( (char *)&(poly->npoints[poly->nrings] ) );
pts = (POINT3D *) MAXALIGN(pts);
line = make_line(poly->npoints[0], pts, &size_line);
//get the ring, make a new geometry
PG_RETURN_POINTER(
make_oneobj_geometry(size_line,
(char *) line,
LINETYPE, geom->is3d,geom->SRID, geom->scale, geom->offsetX, geom->offsetY)
);
}
}
PG_RETURN_NULL();
}
//NumInteriorRings(GEOMETRY) -- find the first polygon in GEOMETRY,
//return the number of interior rings. Return NULL if there is no
//POLYGON(..) in GEOMETRY.
PG_FUNCTION_INFO_V1(numinteriorrings_polygon);
Datum numinteriorrings_polygon(PG_FUNCTION_ARGS)
{
GEOMETRY *geom = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
char *o;
int type1,j;
int32 *offsets1;
POLYGON3D *poly;
offsets1 = (int32 *) ( ((char *) &(geom->objType[0] ))+ sizeof(int32) * geom->nobjs ) ;
for (j=0; j< geom->nobjs; j++) //for each object in geom1
{
o = (char *) geom +offsets1[j] ;
type1= geom->objType[j];
if (type1 == POLYGONTYPE) //polygon object
{
poly = (POLYGON3D *)o;
PG_RETURN_INT32( poly->nrings -1 ) ;
}
}
PG_RETURN_NULL();
}
// InteriorRingN(GEOMETRY,INTEGER) -- find the first polygon in GEOMETRY,
//return the interior ring at index INTEGER (as a linestring). Return
//NULL if there is no POLYGON(..) in GEOMETRY or INTEGER is out of bounds.
// 1st ring = exerior ring
PG_FUNCTION_INFO_V1(interiorringn_polygon);
Datum interiorringn_polygon(PG_FUNCTION_ARGS)
{
GEOMETRY *geom = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
int32 wanted_index =PG_GETARG_INT32(1);
char *o;
int type1,j,t,point_offset;
int32 *offsets1;
POLYGON3D *poly;
LINE3D *line;
POINT3D *pts;
int size_line;
wanted_index -= NfunctionFirstPoint;
offsets1 = (int32 *) ( ((char *) &(geom->objType[0] ))+ sizeof(int32) * geom->nobjs ) ;
for (j=0; j< geom->nobjs; j++) //for each object in geom1
{
o = (char *) geom +offsets1[j] ;
type1= geom->objType[j];
if (type1 == POLYGONTYPE) //polygon object
{
poly = (POLYGON3D *)o;
if ( (wanted_index<0) || (wanted_index> (poly->nrings-2) ) )
PG_RETURN_NULL(); //index out of range
pts = (POINT3D *) ( (char *)&(poly->npoints[poly->nrings] ) );
pts = (POINT3D *) MAXALIGN(pts);
//find the 1st point in wanted ring
point_offset=0;
for (t=0; t< (wanted_index+1); t++)
{
point_offset += poly->npoints[t];
}
line = make_line(poly->npoints[wanted_index+1], &pts[point_offset], &size_line);
//get the ring, make a new geometry
PG_RETURN_POINTER(
make_oneobj_geometry(size_line,
(char *) line,
LINETYPE, geom->is3d, geom->SRID, geom->scale, geom->offsetX, geom->offsetY)
);
}
}
PG_RETURN_NULL();
}
// numgeometries(GEOMETRY) -- if GEOMETRY is a GEOMETRYCOLLECTION, return
//the number of geometries in it, otherwise return NULL.
// if GEOMETRY is a MULTI* type, return the number of sub-types in it.
PG_FUNCTION_INFO_V1(numgeometries_collection);
Datum numgeometries_collection(PG_FUNCTION_ARGS)
{
GEOMETRY *geom = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
if ( (geom->type == COLLECTIONTYPE) ||
(geom->type == MULTIPOINTTYPE) ||
(geom->type == MULTILINETYPE) ||
(geom->type == MULTIPOLYGONTYPE)
)
PG_RETURN_INT32( geom->nobjs ) ;
else
PG_RETURN_NULL();
}
//geometryN(GEOMETRY, INTEGER) -- if GEOMETRY is a GEOMETRYCOLLECTION,
//return the sub-geometry at index INTEGER (0=first geometry), otherwise
//return NULL. NOTE: MULTIPOINT, MULTILINESTRING,MULTIPOLYGON are
//converted to sets of POINT,LINESTRING, and POLYGON so the index may
//change.
// if GEOMETRY is a MULTI* type, return the Nth sub-geometry
PG_FUNCTION_INFO_V1(geometryn_collection);
Datum geometryn_collection(PG_FUNCTION_ARGS)
{
GEOMETRY *geom = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
int32 wanted_index =PG_GETARG_INT32(1);
int type;
int32 *offsets1;
char *o;
wanted_index -= NfunctionFirstPoint;
offsets1 = (int32 *) ( ((char *) &(geom->objType[0] ))+ sizeof(int32) * geom->nobjs ) ;
if (!(( (geom->type == COLLECTIONTYPE) ||
(geom->type == MULTIPOINTTYPE) ||
(geom->type == MULTILINETYPE) ||
(geom->type == MULTIPOLYGONTYPE)
)))
PG_RETURN_NULL();
if ( (wanted_index <0) || (wanted_index > (geom->nobjs-1) ) )
PG_RETURN_NULL(); //bad index
type = geom->objType[wanted_index];
o = (char *) geom +offsets1[wanted_index] ;
if (type == POINTTYPE)
{
PG_RETURN_POINTER(
make_oneobj_geometry(sizeof(POINT3D),
o,
POINTTYPE, geom->is3d, geom->SRID, geom->scale, geom->offsetX, geom->offsetY)
);
}
if (type == LINETYPE)
{
PG_RETURN_POINTER(
make_oneobj_geometry( size_subobject (o, LINETYPE),
o,
LINETYPE, geom->is3d, geom->SRID, geom->scale, geom->offsetX, geom->offsetY)
);
}
if (type == POLYGONTYPE)
{
PG_RETURN_POINTER(
make_oneobj_geometry( size_subobject (o, POLYGONTYPE),
o,
POLYGONTYPE, geom->is3d, geom->SRID, geom->scale, geom->offsetX, geom->offsetY)
);
}
PG_RETURN_NULL();
}
//force the geometry to be a geometrycollection type
PG_FUNCTION_INFO_V1(force_collection);
Datum force_collection(PG_FUNCTION_ARGS)
{
GEOMETRY *geom = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
GEOMETRY *result;
result = (GEOMETRY *) palloc(geom->size);
memcpy(result,geom, geom->size);
result->type = COLLECTIONTYPE;
PG_RETURN_POINTER(result);
}
// point_inside_circle(geometry, Px, Py, d)
// returns true if there is a point in geometry whose distance to (Px,Py) is < d
PG_FUNCTION_INFO_V1(point_inside_circle);
Datum point_inside_circle(PG_FUNCTION_ARGS)
{
GEOMETRY *geom = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
char *o;
int type1,j;
int32 *offsets1;
POINT3D *pt;
double Px = PG_GETARG_FLOAT8(1);
double Py = PG_GETARG_FLOAT8(2);
double d = PG_GETARG_FLOAT8(3);
double dd = d*d; //d squared
offsets1 = (int32 *) ( ((char *) &(geom->objType[0] ))+ sizeof(int32) * geom->nobjs ) ;
//now have to do a scan of each object
for (j=0; j< geom->nobjs; j++) //for each object in geom
{
o = (char *) geom +offsets1[j] ;
type1= geom->objType[j];
if (type1 == POINTTYPE) //point
{
//see if its within d of Px,Py
pt = (POINT3D *) o;
if ( ( (pt->x - Px)*(pt->x - Px) + (pt->y - Py)*(pt->y - Py) ) < dd)
{
PG_RETURN_BOOL(TRUE);
}
}
}
PG_RETURN_BOOL(FALSE);
}
//distance from p to line A->B
double distance_pt_seg(POINT3D *p, POINT3D *A, POINT3D *B)
{
double r,s;
//if start==end, then use pt distance
if ( ( A->x == B->x) && (A->y == B->y) )
return distance_pt_pt(p,A);
//otherwise, we use comp.graphics.algorithms Frequently Asked Questions method
/*(1) AC dot AB
r = ---------
||AB||^2
r has the following meaning:
r=0 P = A
r=1 P = B
r<0 P is on the backward extension of AB
r>1 P is on the forward extension of AB
0x-A->x) * (B->x-A->x) + (p->y-A->y) * (B->y-A->y) )/( (B->x-A->x)*(B->x-A->x) +(B->y-A->y)*(B->y-A->y) );
if (r<0)
return (distance_pt_pt(p,A));
if (r>1)
return(distance_pt_pt(p,B));
/*(2)
(Ay-Cy)(Bx-Ax)-(Ax-Cx)(By-Ay)
s = -----------------------------
L^2
Then the distance from C to P = |s|*L.
*/
s = ((A->y-p->y)*(B->x-A->x)- (A->x-p->x)*(B->y-A->y) )/ ((B->x-A->x)*(B->x-A->x) +(B->y-A->y)*(B->y-A->y) );
return abs(s) * sqrt(((B->x-A->x)*(B->x-A->x) +(B->y-A->y)*(B->y-A->y) ));
}
// find the distance from AB to CD
double distance_seg_seg(POINT3D *A, POINT3D *B, POINT3D *C, POINT3D *D)
{
double s_top, s_bot,s;
double r_top, r_bot,r;
//printf("seg_seg [%g,%g]->[%g,%g] by [%g,%g]->[%g,%g] \n",A->x,A->y,B->x,B->y, C->x,C->y, D->x, D->y);
//A and B are the same point
if ( ( A->x == B->x) && (A->y == B->y) )
return distance_pt_seg(A,C,D);
//U and V are the same point
if ( ( C->x == D->x) && (C->y == D->y) )
return distance_pt_seg(D,A,B);
// AB and CD are line segments
/* from comp.graphics.algo
Solving the above for r and s yields
(Ay-Cy)(Dx-Cx)-(Ax-Cx)(Dy-Cy)
r = ----------------------------- (eqn 1)
(Bx-Ax)(Dy-Cy)-(By-Ay)(Dx-Cx)
(Ay-Cy)(Bx-Ax)-(Ax-Cx)(By-Ay)
s = ----------------------------- (eqn 2)
(Bx-Ax)(Dy-Cy)-(By-Ay)(Dx-Cx)
Let P be the position vector of the intersection point, then
P=A+r(B-A) or
Px=Ax+r(Bx-Ax)
Py=Ay+r(By-Ay)
By examining the values of r & s, you can also determine some other limiting conditions:
If 0<=r<=1 & 0<=s<=1, intersection exists
r<0 or r>1 or s<0 or s>1 line segments do not intersect
If the denominator in eqn 1 is zero, AB & CD are parallel
If the numerator in eqn 1 is also zero, AB & CD are collinear.
*/
r_top = (A->y-C->y)*(D->x-C->x) - (A->x-C->x)*(D->y-C->y) ;
r_bot = (B->x-A->x)*(D->y-C->y) - (B->y-A->y)*(D->x-C->x) ;
s_top = (A->y-C->y)*(B->x-A->x) - (A->x-C->x)*(B->y-A->y);
s_bot = (B->x-A->x)*(D->y-C->y) - (B->y-A->y)*(D->x-C->x);
if ( (r_bot==0) || (s_bot == 0) )
{
return (
min(distance_pt_seg(A,C,D),
min(distance_pt_seg(B,C,D),
min(distance_pt_seg(C,A,B),
distance_pt_seg(D,A,B) ) ) )
);
}
s = s_top/s_bot;
r= r_top/r_bot;
if ((r<0) || (r>1) || (s<0) || (s>1) )
{
//no intersection
return (
min(distance_pt_seg(A,C,D),
min(distance_pt_seg(B,C,D),
min(distance_pt_seg(C,A,B),
distance_pt_seg(D,A,B) ) ) )
);
}
else
return -0; //intersection exists
}
//trivial
double distance_pt_pt(POINT3D *p1, POINT3D *p2)
{
//print_point_debug(p1);
//print_point_debug(p2);
return ( sqrt( (p2->x - p1->x) * (p2->x - p1->x) + (p2->y - p1->y) * (p2->y - p1->y) ) );
}
//search all the segments of line to see which one is closest to p1
double distance_pt_line(POINT3D *p1, LINE3D *l2)
{
double result = 99999999999.9,dist_this;
bool result_okay = FALSE; //result is a valid min
int t;
POINT3D *start,*end;
start = &(l2->points[0]);
for (t =1;tnpoints;t++)
{
end = &(l2->points[t]);
dist_this = distance_pt_seg(p1, start,end);
if (result_okay)
result= min(result,dist_this);
else
{
result_okay = TRUE;
result = dist_this;
}
start =end;
}
return result;
}
// test each segment of l1 against each segment of l2. Return min
double distance_line_line(LINE3D *l1, LINE3D *l2)
{
double result = 99999999999.9,dist_this;
bool result_okay = FALSE; //result is a valid min
int t,u;
POINT3D *start,*end;
POINT3D *start2,*end2;
start = &(l1->points[0]);
for (t =1;tnpoints;t++) //for each segment in L1
{
end = &(l1->points[t]);
start2 = &(l2->points[0]);
for (u=1; u< l2->npoints; u++) //for each segment in L2
{
end2 = &(l2->points[u]);
dist_this = distance_seg_seg(start,end,start2,end2);
//printf("line_line; seg %i * seg %i, dist = %g\n",t,u,dist_this);
if (result_okay)
result= min(result,dist_this);
else
{
result_okay = TRUE;
result = dist_this;
}
if (result <=0)
return 0; //intersection
start2 = end2;
}
start = end;
}
return result;
}
// 1. see if pt in outer boundary. if no, then treat the outer ring like a line
// 2. if in the boundary, test to see if its in a hole. if so, then return dist to hole
double distance_pt_poly(POINT3D *p1, POLYGON3D *poly2)
{
POINT3D *pts; //pts array for polygon
double result;
LINE3D *line;
int junk,t;
int offset;
pts = (POINT3D *) ( (char *)&(poly2->npoints[poly2->nrings] ) );
pts = (POINT3D *) MAXALIGN(pts);
if (PIP( p1, pts, poly2->npoints[0] ) )
{
//inside the outer ring. scan though each of the inner rings looking to
// see if its inside. If not, distance =0. Otherwise, distance =
// pt to ring distance
offset = poly2->npoints[0]; //where ring t starts;
for (t=1; tnrings;t++) //foreach inner ring
{
if ( PIP( p1, &pts[offset], poly2->npoints[t] ) )
{
//inside a hole. Distance = pt -> ring
line = make_line (poly2->npoints[t] , &pts[offset] , &junk);
result = distance_pt_line(p1, line);
pfree(line);
return result;
}
offset += poly2->npoints[t];
}
return 0; //its inside the polygon
}
else
{
//outside the outer ring. Distance = pt -> ring
line = make_line (poly2->npoints[0] , pts, &junk);
result = distance_pt_line(p1, line);
pfree(line);
return result;
}
}
// brute force. Test l1 against each ring. If there's an intersection then return 0 (crosses boundary)
// otherwise, test to see if a point inside outer rings of polygon, but not in inner rings.
// if so, return 0 (line inside polygon)
// otherwise return min distance to a ring (could be outside polygon or inside a hole)
double distance_line_poly(LINE3D *l1, POLYGON3D *poly2)
{
double min_dist=9999999.0,this_dist;
int t,junk;
LINE3D *line;
POINT3D *pts; //pts array for polygon
int offset;
pts = (POINT3D *) ( (char *)&(poly2->npoints[poly2->nrings] ) );
pts = (POINT3D *) MAXALIGN(pts);
offset =0;
for (t=0;tnrings; t++)
{
line = make_line (poly2->npoints[t] , &pts[offset] , &junk);
this_dist = distance_line_line(l1, line);
pfree(line);
//printf("line_poly; ring %i dist = %g\n",t,this_dist);
if (t==0)
min_dist = this_dist;
else
min_dist = min(min_dist,this_dist);
if (min_dist <=0)
return 0; //intersection
offset += poly2->npoints[t];
}
//no intersection, have to check if a point is inside the outer ring
if (PIP( &l1->points[0], pts, poly2->npoints[0] ) )
{
//its in the polygon. Have to check if its inside a hole
//printf("line_poly; inside outer ring\n");
offset =poly2->npoints[0] ;
for (t=1; tnrings;t++) //foreach inner ring
{
if ( PIP( &l1->points[0], &pts[offset], poly2->npoints[t] ) )
{
//its inside a hole, then the actual distance is the min ring distance
//printf("line_poly; inside inner ring %i\n",t);
return min_dist;
}
offset += poly2->npoints[t];
}
// not in hole, there for inside the polygon
return 0;
}
else
{
//not in the outside ring, so min distance to a ring is the actual min distance
return min_dist;
}
}
// true if point is in poly (and not in its holes)
bool point_in_poly(POINT3D *p, POLYGON3D *poly)
{
int t;
POINT3D *pts1;
int offset;
pts1 = (POINT3D *) ( (char *)&(poly->npoints[poly->nrings] ) );
pts1 = (POINT3D *) MAXALIGN(pts1);
if (PIP(p, pts1, poly->npoints[0]))
{
offset = poly->npoints[0];
for (t=1;tnrings;t++)
{
if (PIP(p, &pts1[offset], poly->npoints[t]) )
{
return FALSE; //inside a hole
}
offset += poly->npoints[t];
}
return TRUE; //in outer ring, not in holes
}
else
return FALSE; //not in outer ring
}
// brute force.
// test to see if any rings intersect. if yes, dist =0
// test to see if one inside the other and if they are inside holes.
// find min distance ring-to-ring
double distance_poly_poly(POLYGON3D *poly1, POLYGON3D *poly2)
{
//foreach ring in Poly1
// foreach ring in Poly2
// if intersect, return 0
// if poly1 inside poly2 return 0
// if poly2 inside poly1 return 0
// otherwise return closest approach of rings
int t,junk;
POINT3D *pts1,*pts2;
int32 offset1;
double min_dist= 99999999999.9, this_dist;
LINE3D *line;
pts1 = (POINT3D *) ( (char *)&(poly1->npoints[poly1->nrings] ) );
pts1 = (POINT3D *) MAXALIGN(pts1);
pts2 = (POINT3D *) ( (char *)&(poly2->npoints[poly2->nrings] ) );
pts2 = (POINT3D *) MAXALIGN(pts2);
//do this first as its a quick test
//test if poly1 inside poly2
if (point_in_poly(pts1, poly2) )
return 0;
//test if poly2 inside poly1
if (point_in_poly(pts2, poly1) )
return 0;
offset1 =0;
for (t=0; tnrings; t++) //for each ring in poly1
{
line = make_line (poly1->npoints[t] , &pts1[offset1] , &junk);
this_dist = distance_line_poly(line, poly2);
pfree(line);
//printf("poly_poly; ring %i dist = %g\n",t,this_dist);
if (t==0)
min_dist = this_dist;
else
min_dist = min(min_dist,this_dist);
if (min_dist <=0)
return 0; //intersection
offset1 += poly1->npoints[t];
}
//rings do not intersect
return min_dist;
}
//minimum distance between objects in geom1 and geom2. returns null if it doesnt exist (future null-safe version).
PG_FUNCTION_INFO_V1(distance);
Datum distance(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
GEOMETRY *geom2 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
int g1_i, g2_i;
double dist,this_dist = 0;
bool dist_set = FALSE; //true once dist makes sense.
int32 *offsets1,*offsets2;
int type1,type2;
char *o1,*o2;
if (geom1->SRID != geom2->SRID)
{
elog(ERROR,"Operation on two GEOMETRIES with different SRIDs\n");
PG_RETURN_NULL();
}
dist = 99999999999999999999.9; //very far
offsets1 = (int32 *) ( ((char *) &(geom1->objType[0] ))+ sizeof(int32) * geom1->nobjs ) ;
offsets2 = (int32 *) ( ((char *) &(geom2->objType[0] ))+ sizeof(int32) * geom2->nobjs ) ;
for (g1_i=0; g1_i < geom1->nobjs; g1_i++)
{
o1 = (char *) geom1 +offsets1[g1_i] ;
type1= geom1->objType[g1_i];
for (g2_i=0; g2_i < geom2->nobjs; g2_i++)
{
o2 = (char *) geom2 +offsets2[g2_i] ;
type2= geom2->objType[g2_i];
if ( (type1 == POINTTYPE) && (type2 == POINTTYPE) )
{
this_dist = distance_pt_pt( (POINT3D *)o1, (POINT3D *)o2 );
}
if ( (type1 == POINTTYPE) && (type2 == LINETYPE) )
{
this_dist = distance_pt_line( (POINT3D *)o1, (LINE3D *)o2 );
}
if ( (type1 == POINTTYPE) && (type2 == POLYGONTYPE) )
{
this_dist = distance_pt_poly( (POINT3D *)o1, (POLYGON3D *)o2 );
}
if ( (type1 == LINETYPE) && (type2 == LINETYPE) )
{
this_dist = distance_line_line( (LINE3D *)o1, (LINE3D *)o2 );
}
if ( (type1 == LINETYPE) && (type2 == POLYGONTYPE) )
{
this_dist = distance_line_poly( (LINE3D *)o1, (POLYGON3D *)o2 );
}
if ( (type1 == POLYGONTYPE) && (type2 == POLYGONTYPE) )
{
this_dist = distance_poly_poly( (POLYGON3D *)o1, (POLYGON3D *)o2 );
}
//trival versions based on above dist(a,b) = dist(b,a)
if ( (type1 == LINETYPE) && (type2 == POINTTYPE) )
{
this_dist = distance_pt_line( (POINT3D *)o2, (LINE3D *)o1 );
}
if ( (type1 == POLYGONTYPE) && (type2 == POINTTYPE) )
{
this_dist = distance_pt_poly( (POINT3D *)o2, (POLYGON3D *)o1 );
}
if ( (type1 == POLYGONTYPE) && (type2 == LINETYPE) )
{
this_dist = distance_line_poly( (LINE3D *)o2, (POLYGON3D *)o1 );
}
if (dist_set)
{
dist = min(dist,this_dist);
}
else
{
dist = this_dist; //first one through
dist_set = TRUE;
}
if (dist <= 0.0)
PG_RETURN_FLOAT8( (double) 0.0); // no need to look for things closer
}
}
if (dist <0)
dist = 0; //computational error, may get -0.00000000001
PG_RETURN_FLOAT8(dist);
}
//expand_bbox(bbox3d, d)
// returns a new bbox which is exanded d unit in all directions
PG_FUNCTION_INFO_V1(expand_bbox);
Datum expand_bbox(PG_FUNCTION_ARGS)
{
BOX3D *bbox = (BOX3D *) PG_GETARG_POINTER(0);
double d = PG_GETARG_FLOAT8(1);
BOX3D *result = (BOX3D *) palloc(sizeof(BOX3D));
result->LLB.x = bbox->LLB.x - d;
result->LLB.y = bbox->LLB.y - d;
result->LLB.z = bbox->LLB.z - d;
result->URT.x = bbox->URT.x + d;
result->URT.y = bbox->URT.y + d;
result->URT.z = bbox->URT.z + d;
PG_RETURN_POINTER(result);
}
//startpoint(geometry) :- if geometry is a linestring, return the first
//point. Otherwise, return NULL.
PG_FUNCTION_INFO_V1(startpoint);
Datum startpoint(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
POINT3D *pt;
LINE3D *line;
int32 *offsets1;
if ( (geom1->type != LINETYPE) && (geom1->type != MULTILINETYPE) )
PG_RETURN_NULL();
offsets1 = (int32 *) ( ((char *) &(geom1->objType[0] ))+ sizeof(int32) * geom1->nobjs ) ;
line = (LINE3D *) ( (char *) geom1 +offsets1[0]);
pt = &line->points[0];
PG_RETURN_POINTER(
make_oneobj_geometry(sizeof(POINT3D),
(char *) pt,
POINTTYPE, geom1->is3d, geom1->SRID, geom1->scale, geom1->offsetX, geom1->offsetY)
);
}
//endpoint(geometry) :- if geometry is a linestring, return the last
//point. Otherwise, return NULL.
PG_FUNCTION_INFO_V1(endpoint);
Datum endpoint(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
POINT3D *pt;
LINE3D *line;
int32 *offsets1;
if ( (geom1->type != LINETYPE) && (geom1->type != MULTILINETYPE) )
PG_RETURN_NULL();
offsets1 = (int32 *) ( ((char *) &(geom1->objType[0] ))+ sizeof(int32) * geom1->nobjs ) ;
line = (LINE3D *) ( (char *) geom1 +offsets1[0]);
pt = &line->points[line->npoints-1];
PG_RETURN_POINTER(
make_oneobj_geometry(sizeof(POINT3D),
(char *) pt,
POINTTYPE, geom1->is3d, geom1->SRID, geom1->scale, geom1->offsetX, geom1->offsetY)
);
}
//isclosed(geometry) :- if geometry is a linestring then returns
//startpoint == endpoint. If its not a linestring then return NULL. If
//its a multilinestring, return true only if all the sub-linestrings have
//startpoint=endpoint.
//calculations always done in 3d (even if you do a force2d)
PG_FUNCTION_INFO_V1(isclosed);
Datum isclosed(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
POINT3D *pt1,*pt2;
LINE3D *line;
int32 *offsets1;
int t;
if (!((geom1->type == LINETYPE) || (geom1->type == MULTILINETYPE) ))
PG_RETURN_NULL();
offsets1 = (int32 *) ( ((char *) &(geom1->objType[0] ))+ sizeof(int32) * geom1->nobjs ) ;
for (t=0; t< geom1->nobjs; t++)
{
line = (LINE3D *) ( (char *) geom1 +offsets1[t]);
pt1 = &line->points[0];
pt2 = &line->points[line->npoints-1];
if ( (pt1->x != pt2->x) || (pt1->y != pt2->y) || (pt1->z != pt2->z) )
PG_RETURN_BOOL(FALSE);
}
PG_RETURN_BOOL(TRUE);
}
#ifndef USE_GEOS
PG_FUNCTION_INFO_V1(centroid);
Datum centroid(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
int32 *offsets1;
POINT3D *pts,*cent;
POLYGON3D *poly;
int t,v;
int num_points,num_points_tot;
double tot_x,tot_y,tot_z;
GEOMETRY *result;
offsets1 = (int32 *) ( ((char *) &(geom1->objType[0] ))+ sizeof(int32) * geom1->nobjs ) ;
if (!((geom1->type == POLYGONTYPE) || (geom1->type == MULTIPOLYGONTYPE) ))
PG_RETURN_NULL();
//find the centroid
num_points_tot = 0;
tot_x = 0; tot_y =0; tot_z=0;
for (t=0;tnobjs;t++)
{
poly = (POLYGON3D *) ( (char *) geom1 +offsets1[t]);
pts = (POINT3D *) ( (char *)&(poly->npoints[poly->nrings] ) );
pts = (POINT3D *) MAXALIGN(pts);
num_points =poly->npoints[0];
// just do the outer ring
// for (u=0;unrings;u++)
// {
// num_points += poly->npoints[u];
// }
num_points_tot += num_points-1; //last point = 1st point
for (v=0;vis3d, geom1->SRID, geom1->scale, geom1->offsetX, geom1->offsetY)
);
pfree(cent);
PG_RETURN_POINTER(result);
}
#endif // ! defined USE_GEOS
// max_distance(geom,geom) (both geoms must be linestrings)
//find max distance between l1 and l2
// method: for each point in l1, find distance to l2.
// return max distance
//
// note: max_distance(l1,l2) != max_distance(l2,l1)
// returns double
PG_FUNCTION_INFO_V1(max_distance);
Datum max_distance(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
GEOMETRY *geom2 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
LINE3D *l1,*l2;
int32 *offsets1,*offsets2;
int t;
POINT3D *pt;
double result,dist;
if (geom1->SRID != geom2->SRID)
{
elog(ERROR,"Operation on two GEOMETRIES with different SRIDs\n");
PG_RETURN_NULL();
}
// only works with lines
if ( (geom1->type != LINETYPE) || (geom2->type != LINETYPE) )
PG_RETURN_NULL();
offsets1 = (int32 *) ( ((char *) &(geom1->objType[0] ))+ sizeof(int32) * geom1->nobjs ) ;
offsets2 = (int32 *) ( ((char *) &(geom2->objType[0] ))+ sizeof(int32) * geom2->nobjs ) ;
l1 = (LINE3D *) ( (char *) geom1 +offsets1[0] );
l2 = (LINE3D *) ( (char *) geom2 +offsets2[0] ) ;
result = -9999; // all distances should be positive
for(t=0;tnpoints;t++) //for each point in l1
{
pt = &l1->points[t];
dist = distance_pt_line(pt, l2);
if (dist > result)
{
result = dist;
}
}
if (result <0.0)
result = 0;
PG_RETURN_FLOAT8(result);
}
// optimistic_overlap(Polygon P1, Multipolygon MP2, double dist)
// returns true if P1 overlaps MP2
// method: bbox check - is separation < dist? no - return false (quick)
// yes - return distance(P1,MP2) < dist
PG_FUNCTION_INFO_V1(optimistic_overlap);
Datum optimistic_overlap(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
GEOMETRY *geom2 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
double dist = PG_GETARG_FLOAT8(2);
BOX3D g1_bvol;
double calc_dist;
if (geom1->SRID != geom2->SRID)
{
elog(ERROR,"optimistic_overlap:Operation on two GEOMETRIES with different SRIDs\n");
PG_RETURN_NULL();
}
if (geom1->type != POLYGONTYPE)
{
elog(ERROR,"optimistic_overlap: first arg isnt a polygon\n");
PG_RETURN_NULL();
}
if ( (geom2->type != POLYGONTYPE) && (geom2->type != MULTIPOLYGONTYPE) )
{
elog(ERROR,"optimistic_overlap: 2nd arg isnt a [multi-]polygon\n");
PG_RETURN_NULL();
}
//bbox check
memcpy(&g1_bvol, &geom1->bvol, sizeof(BOX3D) );
g1_bvol.LLB.x = g1_bvol.LLB.x - dist;
g1_bvol.LLB.y = g1_bvol.LLB.y - dist;
g1_bvol.URT.x = g1_bvol.URT.x + dist;
g1_bvol.URT.y = g1_bvol.URT.y + dist;
//xmin = LLB.x, xmax = URT.x
if ( (g1_bvol.LLB.x > geom2->bvol.URT.x) ||
(g1_bvol.URT.x < geom2->bvol.LLB.x) ||
(g1_bvol.LLB.y > geom2->bvol.URT.y) ||
(g1_bvol.URT.y < geom2->bvol.LLB.y)
)
{
PG_RETURN_BOOL(FALSE); //bbox not overlap
}
//compute distances
//should be a fast calc if they actually do intersect
calc_dist = DatumGetFloat8 (DirectFunctionCall2(distance, PointerGetDatum( geom1 ), PointerGetDatum( geom2 )));
PG_RETURN_BOOL(calc_dist < dist);
}
//returns a list of points for a single polygon
// foreach segment
// (1st and last points will be unaltered, but
// there will be more points inbetween if segment length is
POINT3D *segmentize_ring(POINT3D *points, double dist, int num_points_in, int *num_points_out)
{
double seg_distance;
int max_points, offset_new,offset_old;
POINT3D *result,*r;
bool keep_going;
POINT3D *last_point, *next_point;
//initial storage
max_points = 1000;
offset_new=0; //start at beginning of points list
result = (POINT3D *) palloc (sizeof(POINT3D) * max_points);
memcpy(result, points, sizeof(POINT3D) ); //1st point
offset_new++;
last_point = points;
offset_old = 1;
keep_going = 1;
while(keep_going)
{
next_point = &points[offset_old];
//distance last->next > dist
seg_distance = sqrt(
(next_point->x-last_point->x)*(next_point->x-last_point->x) +
(next_point->y-last_point->y)*(next_point->y-last_point->y) );
if (offset_new >= max_points)
{
//need to add new points to result
r = result;
result = (POINT3D *) palloc (sizeof(POINT3D) * max_points *2);//double size
memcpy(result,r, sizeof(POINT3D)*max_points);
max_points *=2;
pfree(r);
}
if (seg_distance > dist)
{
//add a point at the distance location
// and set last_point to this loc
result[offset_new].x = last_point->x + (next_point->x-last_point->x)/seg_distance * dist;
result[offset_new].y = last_point->y + (next_point->y-last_point->y)/seg_distance * dist;
last_point = &result[offset_new];
offset_new ++;
}
else
{
//everything fine, just add the next_point and pop forward
result[offset_new].x = next_point->x;
result[offset_new].y = next_point->y;
offset_new++;
offset_old++;
last_point = next_point;
}
keep_going = (offset_old < num_points_in);
}
*num_points_out = offset_new;
return result;
}
// select segmentize('POLYGON((0 0, 0 10, 5 5, 0 0))',1);
//segmentize(GEOMETRY P1, double maxlen)
//given a [multi-]polygon, return a new polygon with each segment at most a given length
PG_FUNCTION_INFO_V1(segmentize);
Datum segmentize(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
GEOMETRY *result = NULL, *result2;
double maxdist = PG_GETARG_FLOAT8(1);
int32 *offsets1,*p_npoints_ring;
int g1_i,r;
POLYGON3D *p,*poly;
POINT3D *polypts;
int num_polypts;
POINT3D *all_polypts;
int all_num_polypts,all_num_polypts_max;
POINT3D *p_points,*rr;
int new_size;
bool first_one;
int poly_size;
BOX3D *bbox;
first_one = 1;
if ( (geom1->type != POLYGONTYPE) && (geom1->type != MULTIPOLYGONTYPE) )
{
elog(ERROR,"segmentize: 1st arg isnt a [multi-]polygon\n");
PG_RETURN_NULL();
}
offsets1 = (int32 *) ( ((char *) &(geom1->objType[0] ))+ sizeof(int32) * geom1->nobjs ) ;
for (g1_i=0; g1_i < geom1->nobjs; g1_i++)
{
all_num_polypts = 0;
all_num_polypts_max = 1000;
all_polypts = (POINT3D *) palloc (sizeof(POINT3D) * all_num_polypts_max );
p = (POLYGON3D*)((char *) geom1 +offsets1[g1_i]) ; // the polygon
p_npoints_ring = (int32 *) palloc(sizeof(int32) * p->nrings);
p_points = (POINT3D *) ( (char *)&(p->npoints[p->nrings] ) );
p_points = (POINT3D *) MAXALIGN(p_points);
for (r=0;rnrings;r++) //foreach ring in the polygon
{
polypts = segmentize_ring(p_points, maxdist, p->npoints[r], &num_polypts);
if ( (all_num_polypts + num_polypts) < all_num_polypts_max )
{
//just add
memcpy( &all_polypts[all_num_polypts], polypts, sizeof(POINT3D) *num_polypts );
all_num_polypts += num_polypts;
}
else
{
//need more space
new_size = all_num_polypts_max + num_polypts + 1000;
rr = (POINT3D*) palloc(sizeof(POINT3D) * new_size);
memcpy(rr,all_polypts, sizeof(POINT3D) *all_num_polypts);
memcpy(&rr[all_num_polypts], polypts , sizeof(POINT3D) *num_polypts);
pfree(all_polypts);
all_polypts = rr;
all_num_polypts += num_polypts;
}
//set points in ring value
pfree(polypts);
p_npoints_ring[r] = num_polypts;
} //for each ring
poly = make_polygon(p->nrings, p_npoints_ring, all_polypts, all_num_polypts, &poly_size);
if (first_one)
{
first_one = 0;
result = make_oneobj_geometry(poly_size, (char *)poly, POLYGONTYPE, FALSE,geom1->SRID, geom1->scale, geom1->offsetX, geom1->offsetY);
pfree(poly);
pfree(all_polypts);
}
else
{
result2 = add_to_geometry(result,poly_size, (char *) poly, POLYGONTYPE);
bbox = bbox_of_geometry( result2 ); // make bounding box
memcpy( &result2->bvol, bbox, sizeof(BOX3D) ); // copy bounding box
pfree(bbox); // free bounding box
pfree(result);
result = result2;
pfree(poly);
pfree(all_polypts);
}
} // foreach polygon
PG_RETURN_POINTER(result);
}
/*
* This is a geometry array constructor
* for use as aggregates sfunc.
* Will have * as input an array of Geometry pointers and a Geometry.
* Will DETOAST given geometry and put a pointer to it
* in the given array. DETOASTED value is first copied
* to a safe memory context to avoid premature deletion.
*/
PG_FUNCTION_INFO_V1(geom_accum);
Datum geom_accum(PG_FUNCTION_ARGS)
{
ArrayType *array;
int nelems, nbytes;
Datum datum;
GEOMETRY *geom;
ArrayType *result;
Pointer **pointers;
MemoryContext oldcontext;
datum = PG_GETARG_DATUM(0);
if ( (Pointer *)datum == NULL ) {
array = NULL;
nelems = 0;
//elog(NOTICE, "geom_accum: NULL array, nelems=%d", nelems);
} else {
array = (ArrayType *) PG_DETOAST_DATUM_COPY(datum);
nelems = ArrayGetNItems(ARR_NDIM(array), ARR_DIMS(array));
}
datum = PG_GETARG_DATUM(1);
// Do nothing, return state array
if ( (Pointer *)datum == NULL )
{
//elog(NOTICE, "geom_accum: NULL geom, nelems=%d", nelems);
PG_RETURN_ARRAYTYPE_P(array);
}
/*
* Switch to * flinfo->fcinfo->fn_mcxt
* memory context to be sure both detoasted
* geometry AND array of pointers to it
* last till the call to unite_finalfunc.
*/
oldcontext = MemoryContextSwitchTo(fcinfo->flinfo->fn_mcxt);
/* Make a DETOASTED copy of input geometry */
geom = (GEOMETRY *)PG_DETOAST_DATUM_COPY(datum);
//elog(NOTICE, "geom_accum: adding %p (nelems=%d)", geom, nelems);
/*
* Might use a more optimized version instead of repalloc'ing
* at every iteration. This is not the bottleneck anyway.
* --strk(TODO);
*/
++nelems;
nbytes = ARR_OVERHEAD(1) + sizeof(Pointer *) * nelems;
if ( ! array ) {
result = (ArrayType *) palloc(nbytes);
result->size = nbytes;
result->ndim = 1;
*((int *) ARR_DIMS(result)) = nelems;
} else {
result = (ArrayType *) repalloc(array, nbytes);
result->size = nbytes;
result->ndim = 1;
*((int *) ARR_DIMS(result)) = nelems;
}
pointers = (Pointer **)ARR_DATA_PTR(result);
pointers[nelems-1] = (Pointer *)geom;
/* Go back to previous memory context */
MemoryContextSwitchTo(oldcontext);
PG_RETURN_ARRAYTYPE_P(result);
}
/*
* collect_garray ( GEOMETRY[] ) returns a geometry which contains
* all the sub_objects from all of the geometries in given array.
*
* returned geometry is the simplest possible, based on the types
* of the collected objects
* ie. if all are of either X or multiX, then a multiX is returned
* bboxonly types are treated as null geometries (no sub_objects)
*/
PG_FUNCTION_INFO_V1( collect_garray );
Datum collect_garray ( PG_FUNCTION_ARGS )
{
Datum datum;
ArrayType *array;
int nelems, srid=-1, is3d=0;
GEOMETRY **geoms;
GEOMETRY *result=NULL, *geom, *tmp;
int i, o;
BOX3D *bbox;
/* Get input datum */
datum = PG_GETARG_DATUM(0);
/* Return null on null input */
if ( (Pointer *)datum == NULL ) PG_RETURN_NULL();
/* Get actual ArrayType */
array = (ArrayType *) PG_DETOAST_DATUM(datum);
/* Get number of geometries in array */
nelems = ArrayGetNItems(ARR_NDIM(array), ARR_DIMS(array));
/* Return null on 0-elements input array */
if ( nelems == 0 ) PG_RETURN_NULL();
/* Get pointer to GEOMETRY pointers array */
geoms = (GEOMETRY **)ARR_DATA_PTR(array);
/* Return the only present element of a 1-element array */
if ( nelems == 1 ) PG_RETURN_POINTER(geoms[0]);
/* Iterate over all geometries in array */
for (i=0; iSRID;
/* Get first geometry's is3d flag as base is3d */
is3d = geom->is3d;
result = (GEOMETRY *)palloc(geom->size);
if ( ! result ) {
elog(ERROR, "collect_garray: out of virtual memory");
PG_RETURN_NULL();
}
memcpy(result, geom, geom->size);
/*
* I belive memory associated with geometries
* in array can be safely removed. Comment
* this out if you get memory faults!
* TODO: inspect this (as long as passed
* array is the result of geom_accum this
* is true because geom_accum will DETOAST_COPY
* while for direct user call I do not know)
*/
pfree(geom);
continue;
}
/* Skip geometry if it contains no sub-objects */
if ( ! geom->nobjs )
{
if ( geom->is3d ) is3d = 1; // should I care ?
pfree(geom); // se note above
continue;
}
/*
* If we are here this means we are in front of a
* good (non empty) geometry beside the first
*/
/* Fist let's check for SRID compatibility */
if ( geom->SRID != srid )
{
elog(ERROR, "Operation on GEOMETRIES with different SRIDs");
PG_RETURN_NULL();
}
/*
* Set result is3d flag to true if at least one
* of geometries in set has is set to true
*/
if ( geom->is3d ) is3d = 1;
/* Get to sub-objects offset */
offsets = (int32 *)(((char *)&(geom->objType[0])) +
sizeof(int32) * geom->nobjs ) ;
/* Iterate over geometry sub-objects */
for (o=0; onobjs; o++)
{
int size, type;
char *obj;
/* Get object pointer */
obj = (char *) geom+offsets[o];
/* Get object type */
type = geom->objType[o];
/* Get object size (fast way) */
if( o == geom->nobjs-1 ) {
size = geom->size - offsets[o];
} else {
size = offsets[o+1] - offsets[o];
}
/*
* Add sub-object to base geometry,
* replace base geometry with new one.
*/
tmp = add_to_geometry(result, size, obj, type);
pfree( result );
result = tmp;
}
pfree(geom); // se note above
}
/* Check we got something in our result */
if ( result == NULL ) PG_RETURN_NULL();
/*
* We should now have a big fat geometry composed of all
* sub-objects from all geometries in array
*/
/* Set is3d flag */
result->is3d = is3d;
/* Construct bounding volume */
bbox = bbox_of_geometry( result ); // make
memcpy( &result->bvol, bbox, sizeof(BOX3D) ); // copy
pfree( bbox ); // release
PG_RETURN_POINTER( result );
}
// collector( geom, geom ) returns a geometry which contains
// all the sub_objects from both of the argument geometries
// returned geometry is the simplest possible, based on the types
// of the colelct objects
// ie. if all are of either X or multiX, then a multiX is returned
// bboxonly types are treated as null geometries (no sub_objects)
PG_FUNCTION_INFO_V1( collector );
Datum collector( PG_FUNCTION_ARGS )
{
Pointer geom1_ptr = PG_GETARG_POINTER(0);
Pointer geom2_ptr = PG_GETARG_POINTER(1);
GEOMETRY *geom1, *geom2, *temp, *result;
BOX3D *bbox;
int32 i, size, *offsets2;
// return null if both geoms are null
if ( (geom1_ptr == NULL) && (geom2_ptr == NULL) )
{
PG_RETURN_NULL();
}
// return a copy of the second geom if only first geom is null
if (geom1_ptr == NULL)
{
geom2 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
result = (GEOMETRY *)palloc( geom2->size );
memcpy( result, geom2, geom2->size );
PG_RETURN_POINTER(result);
}
// return a copy of the first geom if only second geom is null
if (geom2_ptr == NULL)
{
geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
result = (GEOMETRY *)palloc( geom1->size );
memcpy( result, geom1, geom1->size );
PG_RETURN_POINTER(result);
}
geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
geom2 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
if ( geom1->SRID != geom2->SRID )
{
elog(ERROR,"Operation on two GEOMETRIES with different SRIDs\n");
PG_RETURN_NULL();
}
if (geom1->nobjs ==0)
{
geom2 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
result = (GEOMETRY *)palloc( geom2->size );
memcpy( result, geom2, geom2->size );
PG_RETURN_POINTER(result);
}
if (geom2->nobjs ==0)
{
geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
result = (GEOMETRY *)palloc( geom1->size );
memcpy( result, geom1, geom1->size );
PG_RETURN_POINTER(result);
}
result = (GEOMETRY *)palloc( geom1->size );
memcpy( result, geom1, geom1->size );
offsets2 = (int32 *)( ((char *)&(geom2->objType[0])) + sizeof( int32 ) * geom2->nobjs ) ;
for (i=0; inobjs; i++)
{
if( i == geom2->nobjs-1 )
{
size = geom2->size - offsets2[i];
}
else
{
size = offsets2[i+1] - offsets2[i];
}
temp = add_to_geometry( result, size, ((char *) geom2 + offsets2[i]), geom2->objType[i] );
pfree( result );
result = temp;
}
result->is3d = geom1->is3d || geom2->is3d;
bbox = bbox_of_geometry( result ); // make bounding box
memcpy( &result->bvol, bbox, sizeof(BOX3D) ); // copy bounding box
pfree( bbox ); // free bounding box
PG_RETURN_POINTER( result );
}
PG_FUNCTION_INFO_V1(box3d_xmin);
Datum box3d_xmin(PG_FUNCTION_ARGS)
{
BOX3D *box1 = (BOX3D *) PG_GETARG_POINTER(0);
PG_RETURN_FLOAT8(box1->LLB.x);
}
PG_FUNCTION_INFO_V1(box3d_ymin);
Datum box3d_ymin(PG_FUNCTION_ARGS)
{
BOX3D *box1 = (BOX3D *) PG_GETARG_POINTER(0);
PG_RETURN_FLOAT8(box1->LLB.y);
}
PG_FUNCTION_INFO_V1(box3d_zmin);
Datum box3d_zmin(PG_FUNCTION_ARGS)
{
BOX3D *box1 = (BOX3D *) PG_GETARG_POINTER(0);
PG_RETURN_FLOAT8(box1->LLB.z);
}
PG_FUNCTION_INFO_V1(box3d_xmax);
Datum box3d_xmax(PG_FUNCTION_ARGS)
{
BOX3D *box1 = (BOX3D *) PG_GETARG_POINTER(0);
PG_RETURN_FLOAT8(box1->URT.x);
}
PG_FUNCTION_INFO_V1(box3d_ymax);
Datum box3d_ymax(PG_FUNCTION_ARGS)
{
BOX3D *box1 = (BOX3D *) PG_GETARG_POINTER(0);
PG_RETURN_FLOAT8(box1->URT.y);
}
PG_FUNCTION_INFO_V1(box3d_zmax);
Datum box3d_zmax(PG_FUNCTION_ARGS)
{
BOX3D *box1 = (BOX3D *) PG_GETARG_POINTER(0);
PG_RETURN_FLOAT8(box1->URT.z);
}
PG_FUNCTION_INFO_V1(box3dtobox);
Datum box3dtobox(PG_FUNCTION_ARGS)
{
BOX3D *box1 = (BOX3D *) PG_GETARG_POINTER(0);
BOX *out;
out = convert_box3d_to_box(box1);
PG_RETURN_POINTER(out);
}
PG_FUNCTION_INFO_V1(isempty);
Datum isempty(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1= (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
if (geom1->nobjs ==0)
PG_RETURN_BOOL(TRUE);
PG_RETURN_BOOL(FALSE);
}
// converts multi* types with 1 element to the single-element version.
// ie. MULTIPOINT(0 0) --> POINT(0 0)
void compressType(GEOMETRY *g)
{
if (g->nobjs ==1)
{
if (g->type == MULTIPOINTTYPE)
{
g->type = POINTTYPE;
return;
}
if (g->type == MULTILINETYPE)
{
g->type = LINETYPE;
return;
}
if (g->type == MULTIPOLYGONTYPE)
{
g->type = POLYGONTYPE;
return;
}
}
}
postgis-0.8.1/postgis_geos.c 0100664 0000773 0000144 00000137035 07766327221 015524 0 ustar postgis users /**********************************************************************
* $Id: postgis_geos.c,v 1.26 2025/12/12 12:03:29 strk Exp $
*
* PostGIS - Spatial Types for PostgreSQL
* http://postgis.refractions.net
* Copyright 2001-2003 Refractions Research Inc.
*
* This is free software; you can redistribute and/or modify it under
* the terms of hte GNU General Public Licence. See the COPYING file.
*
**********************************************************************
* $Log: postgis_geos.c,v $
* Revision 1.26 2025/12/12 12:03:29 strk
* More debugging output, some code cleanup.
*
* Revision 1.25 2025/12/12 10:28:50 strk
* added GEOSnoop OUTPUT debugging info
*
* Revision 1.24 2025/12/12 10:08:24 strk
* Added GEOSnoop function and some optional debugging output for
* geos<->postgis converter (define DEBUG_CONVERTER at top postgis_geos.c)
*
* Revision 1.23 2025/11/05 18:25:08 strk
* moved #ifdef USE_GEOS below prototypes, added NULL implementation of unite_garray
*
* Revision 1.22 2025/11/05 18:02:41 strk
* renamed unite_finalfunc to unite_garray
*
* Revision 1.21 2025/11/04 19:06:08 strk
* added missing first geom pfree in unite_finalfunc
*
* Revision 1.20 2025/10/29 15:53:10 strk
* geoscentroid() removed. both geos and pgis versions are called 'centroid'.
* only one version will be compiled based on USE_GEOS flag.
*
* Revision 1.19 2025/10/29 13:59:40 strk
* Added geoscentroid function.
*
* Revision 1.18 2025/10/28 15:16:17 strk
* unite_sfunc() from postgis_geos.c renamed to geom_accum() and moved in postgis_fn.c
*
* Revision 1.17 2025/10/28 10:59:55 strk
* handled NULL state array in unite_finalfunc, cleaned up some spurios code
*
* Revision 1.16 2025/10/27 23:44:54 strk
* unite_sfunc made always copy input array in long lived memory context.
* It should now work with safer memory.
*
* Revision 1.15 2025/10/27 20:13:05 strk
* Made GeomUnion release memory soon, Added fastunion support functions
*
* Revision 1.14 2025/10/24 21:52:35 strk
* Modified strcmp-based if-else with switch-case in GEOS2POSTGIS()
* using new GEOSGeometryTypeId() interface.
*
* Revision 1.13 2025/10/24 08:28:49 strk
* Fixed memory leak in GEOSGetCoordinates(), made sure that GEOS2POSTGIS
* free type string even in case of collapsed geoms. Made sure that geomunion
* release memory in case of exception thrown by GEOSUnion. Sooner release
* of palloced memory in PolyFromGeometry (pts_per_ring).
*
* Revision 1.12 2025/10/16 20:16:18 dblasby
* Added NOTICE_HANDLER function. For some reason this didnt get properly
* committed last time.
*
* Revision 1.11 2025/10/14 23:19:19 dblasby
* GEOS2POSTGIS - added protection to pfree(NULL) for multi* geoms
*
* Revision 1.10 2025/10/03 16:45:37 dblasby
* added pointonsurface() as a sub. Some memory management fixes/tests.
* removed a few NOTICEs.
*
* Revision 1.9 2025/09/16 20:27:12 dblasby
* added ability to delete geometries.
*
* Revision 1.8 2025/08/08 18:19:20 dblasby
* Conformance changes.
* Removed junk from postgis_debug.c and added the first run of the long
* transaction locking support. (this will change - dont use it)
* conformance tests were corrected
* some dos cr/lf removed
* empty geometries i.e. GEOMETRYCOLLECT(EMPTY) added (with indexing support)
* pointN(,1) now returns the first point (used to return 2nd)
*
* Revision 1.7 2025/08/06 19:31:18 dblasby
* Added the WKB parser. Added all the functions like
* PolyFromWKB(,[]).
*
* Added all the functions like PolyFromText(,[])
*
* Minor problem in GEOS library fixed.
*
* Revision 1.6 2025/08/05 18:27:21 dblasby
* Added null implementations of new GEOS-returning-geometry functions (ie.
* buffer).
*
* Revision 1.5 2025/08/01 23:58:08 dblasby
* added the functionality to convert GEOS->PostGIS geometries. Added those geos
* functions to postgis.
*
* Revision 1.4 2025/07/01 18:30:55 pramsey
* Added CVS revision headers.
*
*
**********************************************************************/
//--------------------------------------------------------------------------
//
//#define DEBUG
#include "postgres.h"
#include
#include
#include
#include
#include
#include "fmgr.h"
#include "postgis.h"
#include "utils/elog.h"
#include "utils/array.h"
#include "access/gist.h"
#include "access/itup.h"
#include "access/rtree.h"
#include "utils/builtins.h"
/*
* Define this to have have many notices printed
* during postgis->geos and geos->postgis conversions
*/
#undef DEBUG_CONVERTER
#undef DEBUG_POSTGIS2GEOS
#undef DEBUG_GEOS2POSTGIS
typedef struct Geometry Geometry;
extern const char * createGEOSPoint(POINT3D *pt);
extern void initGEOS(int maxalign);
extern char *GEOSrelate(Geometry *g1, Geometry*g2);
extern char GEOSrelatePattern(Geometry *g1, Geometry*g2,char *pat);
extern char GEOSrelateDisjoint(Geometry *g1, Geometry*g2);
extern char GEOSrelateTouches(Geometry *g1, Geometry*g2);
extern char GEOSrelateIntersects(Geometry *g1, Geometry*g2);
extern char GEOSrelateCrosses(Geometry *g1, Geometry*g2);
extern char GEOSrelateWithin(Geometry *g1, Geometry*g2);
extern char GEOSrelateContains(Geometry *g1, Geometry*g2);
extern char GEOSrelateOverlaps(Geometry *g1, Geometry*g2);
extern char *GEOSasText(Geometry *g1);
extern char GEOSisEmpty(Geometry *g1);
extern char *GEOSGeometryType(Geometry *g1);
extern int GEOSGeometryTypeId(Geometry *g1);
extern void GEOSdeleteChar(char *a);
extern void GEOSdeleteGeometry(Geometry *a);
extern Geometry *PostGIS2GEOS_point(POINT3D *point,int SRID, bool is3d);
extern Geometry *PostGIS2GEOS_linestring(LINE3D *line,int SRID, bool is3d);
extern Geometry *PostGIS2GEOS_polygon(POLYGON3D *polygon,int SRID, bool is3d);
extern Geometry *PostGIS2GEOS_multipolygon(POLYGON3D **polygons,int npolys, int SRID, bool is3d);
extern Geometry *PostGIS2GEOS_multilinestring(LINE3D **lines,int nlines, int SRID, bool is3d);
extern Geometry *PostGIS2GEOS_multipoint(POINT3D **points,int npoints, int SRID, bool is3d);
extern Geometry *PostGIS2GEOS_box3d(BOX3D *box, int SRID);
extern Geometry *PostGIS2GEOS_collection(Geometry **geoms, int ngeoms,int SRID, bool is3d);
extern char GEOSisvalid(Geometry *g1);
extern char *throw_exception(Geometry *g);
extern Geometry *GEOSIntersection(Geometry *g1, Geometry *g2);
extern POINT3D *GEOSGetCoordinate(Geometry *g1);
extern POINT3D *GEOSGetCoordinates(Geometry *g1);
extern int GEOSGetNumCoordinate(Geometry *g1);
extern Geometry *GEOSGetGeometryN(Geometry *g1, int n);
extern Geometry *GEOSGetExteriorRing(Geometry *g1);
extern Geometry *GEOSGetInteriorRingN(Geometry *g1,int n);
extern int GEOSGetNumInteriorRings(Geometry *g1);
extern int GEOSGetSRID(Geometry *g1);
extern int GEOSGetNumGeometries(Geometry *g1);
extern Geometry *GEOSBuffer(Geometry *g1,double width);
extern Geometry *GEOSConvexHull(Geometry *g1);
extern Geometry *GEOSDifference(Geometry *g1,Geometry *g2);
extern Geometry *GEOSBoundary(Geometry *g1);
extern Geometry *GEOSSymDifference(Geometry *g1,Geometry *g2);
extern Geometry *GEOSUnion(Geometry *g1,Geometry *g2);
extern char GEOSequals(Geometry *g1, Geometry*g2);
extern char GEOSisSimple(Geometry *g1);
extern char GEOSisRing(Geometry *g1);
extern Geometry *GEOSpointonSurface(Geometry *g1);
extern Geometry *GEOSGetCentroid(Geometry *g);
Datum relate_full(PG_FUNCTION_ARGS);
Datum relate_pattern(PG_FUNCTION_ARGS);
Datum disjoint(PG_FUNCTION_ARGS);
Datum touches(PG_FUNCTION_ARGS);
Datum intersects(PG_FUNCTION_ARGS);
Datum crosses(PG_FUNCTION_ARGS);
Datum within(PG_FUNCTION_ARGS);
Datum contains(PG_FUNCTION_ARGS);
Datum overlaps(PG_FUNCTION_ARGS);
Datum isvalid(PG_FUNCTION_ARGS);
Datum buffer(PG_FUNCTION_ARGS);
Datum intersection(PG_FUNCTION_ARGS);
Datum convexhull(PG_FUNCTION_ARGS);
Datum difference(PG_FUNCTION_ARGS);
Datum boundary(PG_FUNCTION_ARGS);
Datum symdifference(PG_FUNCTION_ARGS);
Datum geomunion(PG_FUNCTION_ARGS);
Datum unite_garray(PG_FUNCTION_ARGS);
Datum issimple(PG_FUNCTION_ARGS);
Datum isring(PG_FUNCTION_ARGS);
Datum geomequals(PG_FUNCTION_ARGS);
Datum pointonsurface(PG_FUNCTION_ARGS);
Datum GEOSnoop(PG_FUNCTION_ARGS);
Geometry *POSTGIS2GEOS(GEOMETRY *g);
void errorIfGeometryCollection(GEOMETRY *g1, GEOMETRY *g2);
GEOMETRY *GEOS2POSTGIS(Geometry *g, char want3d );
POLYGON3D *PolyFromGeometry(Geometry *g, int *size);
LINE3D *LineFromGeometry(Geometry *g, int *size);
void NOTICE_MESSAGE(char *msg);
#ifdef USE_GEOS
//-----------------------------------------------
// return a GEOS Geometry from a POSTGIS GEOMETRY
//----------------------------------------------
void NOTICE_MESSAGE(char *msg)
{
elog(NOTICE,msg);
}
/*
* Resize an ArrayType of 1 dimension to contain num (Pointer *) elements
* array will be repalloc'ed
*/
static ArrayType *
resize_ptrArrayType(ArrayType *a, int num)
{
int nelems = ArrayGetNItems(ARR_NDIM(a), ARR_DIMS(a));
int nbytes = ARR_OVERHEAD(1) + sizeof(Pointer *) * num;
if (num == nelems) return a;
a = (ArrayType *) repalloc(a, nbytes);
a->size = nbytes;
a->ndim = 1;
*((int *) ARR_DIMS(a)) = num;
return a;
}
/*
* This is the final function for union/fastunite/geomunion
* aggregate (still discussing the name). Will have
* as input an array of Geometry pointers.
* Will iteratively call GEOSUnion on the GEOS-converted
* versions of them and return PGIS-converted version back.
* Changing combination order *might* speed up performance.
*
* Geometries in the array are pfree'd as soon as possible.
*
*/
PG_FUNCTION_INFO_V1(unite_garray);
Datum unite_garray(PG_FUNCTION_ARGS)
{
Datum datum;
ArrayType *array;
int is3d = 0;
int nelems, i;
GEOMETRY **geoms, *result, *pgis_geom;
Geometry *g1, *g2, *geos_result;
#ifdef DEBUG
static int call=1;
#endif
#ifdef DEBUG
call++;
#endif
datum = PG_GETARG_DATUM(0);
/* Null array, null geometry (should be empty?) */
if ( (Pointer *)datum == NULL ) PG_RETURN_NULL();
array = (ArrayType *) PG_DETOAST_DATUM(datum);
nelems = ArrayGetNItems(ARR_NDIM(array), ARR_DIMS(array));
#ifdef DEBUG
elog(NOTICE, "unite_garray: number of elements: %d", nelems);
#endif
if ( nelems == 0 ) PG_RETURN_NULL();
geoms = (GEOMETRY **)ARR_DATA_PTR(array);
/* One-element union is the element itself */
if ( nelems == 1 ) PG_RETURN_POINTER(geoms[0]);
/* Ok, we really need geos now ;) */
initGEOS(MAXIMUM_ALIGNOF);
if ( geoms[0]->is3d ) is3d = 1;
geos_result = POSTGIS2GEOS(geoms[0]);
pfree(geoms[0]);
for (i=1; iis3d || geom2->is3d);
GEOSdeleteGeometry(g3);
if (result == NULL)
{
elog(ERROR,"GEOS union() threw an error (result postgis geometry formation)!");
PG_RETURN_NULL(); //never get here
}
compressType(result); // convert multi* to single item if appropriate
PG_RETURN_POINTER(result);
}
// select symdifference('POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))','POLYGON((5 5, 15 5, 15 7, 5 7, 5 5))');
PG_FUNCTION_INFO_V1(symdifference);
Datum symdifference(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
GEOMETRY *geom2 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
Geometry *g1,*g2,*g3;
GEOMETRY *result;
initGEOS(MAXIMUM_ALIGNOF);
g1 = POSTGIS2GEOS(geom1 );
g2 = POSTGIS2GEOS(geom2 );
g3 = GEOSSymDifference(g1,g2);
if (g3 == NULL)
{
elog(ERROR,"GEOS symdifference() threw an error!");
GEOSdeleteGeometry(g1);
GEOSdeleteGeometry(g2);
PG_RETURN_NULL(); //never get here
}
// elog(NOTICE,"result: %s", GEOSasText(g3) ) ;
result = GEOS2POSTGIS(g3, geom1->is3d || geom2->is3d);
if (result == NULL)
{
GEOSdeleteGeometry(g1);
GEOSdeleteGeometry(g2);
GEOSdeleteGeometry(g3);
elog(ERROR,"GEOS symdifference() threw an error (result postgis geometry formation)!");
PG_RETURN_NULL(); //never get here
}
GEOSdeleteGeometry(g1);
GEOSdeleteGeometry(g2);
GEOSdeleteGeometry(g3);
compressType(result); // convert multi* to single item if appropriate
PG_RETURN_POINTER(result);
}
PG_FUNCTION_INFO_V1(boundary);
Datum boundary(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
Geometry *g1,*g3;
GEOMETRY *result;
initGEOS(MAXIMUM_ALIGNOF);
g1 = POSTGIS2GEOS(geom1 );
g3 = GEOSBoundary(g1);
if (g3 == NULL)
{
elog(ERROR,"GEOS bounary() threw an error!");
GEOSdeleteGeometry(g1);
PG_RETURN_NULL(); //never get here
}
// elog(NOTICE,"result: %s", GEOSasText(g3) ) ;
result = GEOS2POSTGIS(g3, geom1->is3d);
if (result == NULL)
{
GEOSdeleteGeometry(g1);
GEOSdeleteGeometry(g3);
elog(ERROR,"GEOS bounary() threw an error (result postgis geometry formation)!");
PG_RETURN_NULL(); //never get here
}
GEOSdeleteGeometry(g1);
GEOSdeleteGeometry(g3);
compressType(result); // convert multi* to single item if appropriate
PG_RETURN_POINTER(result);
}
PG_FUNCTION_INFO_V1(convexhull);
Datum convexhull(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
Geometry *g1,*g3;
GEOMETRY *result;
initGEOS(MAXIMUM_ALIGNOF);
g1 = POSTGIS2GEOS(geom1 );
g3 = GEOSConvexHull(g1);
if (g3 == NULL)
{
elog(ERROR,"GEOS convexhull() threw an error!");
GEOSdeleteGeometry(g1);
PG_RETURN_NULL(); //never get here
}
// elog(NOTICE,"result: %s", GEOSasText(g3) ) ;
result = GEOS2POSTGIS(g3, geom1->is3d);
if (result == NULL)
{
GEOSdeleteGeometry(g1);
GEOSdeleteGeometry(g3);
elog(ERROR,"GEOS convexhull() threw an error (result postgis geometry formation)!");
PG_RETURN_NULL(); //never get here
}
GEOSdeleteGeometry(g1);
GEOSdeleteGeometry(g3);
compressType(result); // convert multi* to single item if appropriate
PG_RETURN_POINTER(result);
}
PG_FUNCTION_INFO_V1(buffer);
Datum buffer(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
double size = PG_GETARG_FLOAT8(1);
Geometry *g1,*g3;
GEOMETRY *result;
initGEOS(MAXIMUM_ALIGNOF);
g1 = POSTGIS2GEOS(geom1 );
g3 = GEOSBuffer(g1,size);
if (g3 == NULL)
{
elog(ERROR,"GEOS buffer() threw an error!");
GEOSdeleteGeometry(g1);
PG_RETURN_NULL(); //never get here
}
// elog(NOTICE,"result: %s", GEOSasText(g3) ) ;
result = GEOS2POSTGIS(g3, geom1->is3d);
if (result == NULL)
{
GEOSdeleteGeometry(g1);
GEOSdeleteGeometry(g3);
elog(ERROR,"GEOS buffer() threw an error (result postgis geometry formation)!");
PG_RETURN_NULL(); //never get here
}
GEOSdeleteGeometry(g1);
GEOSdeleteGeometry(g3);
compressType(result); // convert multi* to single item if appropriate
PG_RETURN_POINTER(result);
}
//select intersection('POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))','POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))');
//select intersection('POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))','POLYGON((5 5, 15 5, 15 7, 5 7, 5 5))');
//select intersection('POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))','POLYGON((25 5, 35 5, 35 7, 25 7, 25 5))');
//select intersection('POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))','POINT(5 5)');
//select intersection('POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))','LINESTRING(5 5, 10 10)');
//select intersection('POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))','MULTIPOINT(5 5, 7 7, 9 9, 10 10, 11 11)');
//select intersection('POLYGON(( 0 0, 10 0, 10 10, 0 10, 0 0))','POLYGON((5 5, 15 5, 15 7, 5 7, 5 5 ),(6 6,6.5 6, 6.5 6.5,6 6.5,6 6))');
////select intersection('POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))','MULTIPOINT(5 5, 7 7, 9 9, 10 10, 11 11)');
// select intersection('POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))','MULTILINESTRING((5 5, 10 10),(1 1, 2 2) )');
//select intersection('POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))','MULTILINESTRING((5 5, 10 10),(1 1, 2 2) )');
//select intersection('POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))','MULTIPOLYGON(((5 5, 15 5, 15 7, 5 7, 5 5)),((1 1,1 2,2 2,1 2, 1 1)))');
PG_FUNCTION_INFO_V1(intersection);
Datum intersection(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
GEOMETRY *geom2 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
Geometry *g1,*g2,*g3;
GEOMETRY *result;
initGEOS(MAXIMUM_ALIGNOF);
//elog(NOTICE,"intersection() START");
g1 = POSTGIS2GEOS(geom1 );
g2 = POSTGIS2GEOS(geom2 );
//elog(NOTICE," constructed geometrys - calling geos");
//elog(NOTICE,"g1 = %s",GEOSasText(g1));
//elog(NOTICE,"g2 = %s",GEOSasText(g2));
//if (g1==NULL)
// elog(NOTICE,"g1 is null");
//if (g2==NULL)
// elog(NOTICE,"g2 is null");
//elog(NOTICE,"g2 is valid = %i",GEOSisvalid(g2));
//elog(NOTICE,"g1 is valid = %i",GEOSisvalid(g1));
g3 = GEOSIntersection(g1,g2);
//elog(NOTICE," intersection finished");
if (g3 == NULL)
{
elog(ERROR,"GEOS Intersection() threw an error!");
GEOSdeleteGeometry(g1);
GEOSdeleteGeometry(g2);
PG_RETURN_NULL(); //never get here
}
// elog(NOTICE,"result: %s", GEOSasText(g3) ) ;
result = GEOS2POSTGIS(g3, geom1->is3d || geom2->is3d);
if (result == NULL)
{
GEOSdeleteGeometry(g1);
GEOSdeleteGeometry(g2);
GEOSdeleteGeometry(g3);
elog(ERROR,"GEOS Intersection() threw an error (result postgis geometry formation)!");
PG_RETURN_NULL(); //never get here
}
GEOSdeleteGeometry(g1);
GEOSdeleteGeometry(g2);
GEOSdeleteGeometry(g3);
compressType(result); // convert multi* to single item if appropriate
PG_RETURN_POINTER(result);
}
//select difference('POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))','POLYGON((5 5, 15 5, 15 7, 5 7, 5 5))');
PG_FUNCTION_INFO_V1(difference);
Datum difference(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
GEOMETRY *geom2 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
Geometry *g1,*g2,*g3;
GEOMETRY *result;
initGEOS(MAXIMUM_ALIGNOF);
g1 = POSTGIS2GEOS(geom1 );
g2 = POSTGIS2GEOS(geom2 );
g3 = GEOSDifference(g1,g2);
if (g3 == NULL)
{
elog(ERROR,"GEOS difference() threw an error!");
GEOSdeleteGeometry(g1);
GEOSdeleteGeometry(g2);
PG_RETURN_NULL(); //never get here
}
// elog(NOTICE,"result: %s", GEOSasText(g3) ) ;
result = GEOS2POSTGIS(g3, geom1->is3d || geom2->is3d);
if (result == NULL)
{
GEOSdeleteGeometry(g1);
GEOSdeleteGeometry(g2);
GEOSdeleteGeometry(g3);
elog(ERROR,"GEOS difference() threw an error (result postgis geometry formation)!");
PG_RETURN_NULL(); //never get here
}
GEOSdeleteGeometry(g1);
GEOSdeleteGeometry(g2);
GEOSdeleteGeometry(g3);
compressType(result); // convert multi* to single item if appropriate
PG_RETURN_POINTER(result);
}
//select pointonsurface('POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))');
PG_FUNCTION_INFO_V1(pointonsurface);
Datum pointonsurface(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
Geometry *g1,*g3;
GEOMETRY *result;
initGEOS(MAXIMUM_ALIGNOF);
g1 = POSTGIS2GEOS(geom1 );
g3 = GEOSpointonSurface(g1);
if (g3 == NULL)
{
elog(ERROR,"GEOS pointonsurface() threw an error!");
GEOSdeleteGeometry(g1);
PG_RETURN_NULL(); //never get here
}
// elog(NOTICE,"result: %s", GEOSasText(g3) ) ;
result = GEOS2POSTGIS(g3, geom1->is3d);
if (result == NULL)
{
GEOSdeleteGeometry(g1);
GEOSdeleteGeometry(g3);
elog(ERROR,"GEOS pointonsurface() threw an error (result postgis geometry formation)!");
PG_RETURN_NULL(); //never get here
}
GEOSdeleteGeometry(g1);
GEOSdeleteGeometry(g3);
compressType(result); // convert multi* to single item if appropriate
PG_RETURN_POINTER(result);
}
PG_FUNCTION_INFO_V1(centroid);
Datum centroid(PG_FUNCTION_ARGS)
{
GEOMETRY *geom, *result;
Geometry *geosgeom, *geosresult;
geom = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
initGEOS(MAXIMUM_ALIGNOF);
geosgeom = POSTGIS2GEOS(geom);
geosresult = GEOSGetCentroid(geosgeom);
if ( geosresult == NULL )
{
GEOSdeleteGeometry(geosgeom);
elog(ERROR,"GEOS getCentroid() threw an error!");
PG_RETURN_NULL();
}
result = GEOS2POSTGIS(geosresult, geom->is3d);
if (result == NULL)
{
GEOSdeleteGeometry(geosgeom);
GEOSdeleteGeometry(geosresult);
elog(ERROR,"Error in GEOS-PGIS conversion");
PG_RETURN_NULL();
}
GEOSdeleteGeometry(geosgeom);
GEOSdeleteGeometry(geosresult);
PG_RETURN_POINTER(result);
}
//----------------------------------------------
void errorIfGeometryCollection(GEOMETRY *g1, GEOMETRY *g2)
{
if ( (g1->type == COLLECTIONTYPE) || (g2->type == COLLECTIONTYPE) )
elog(ERROR,"Relate Operation called with a GEOMETRYCOLLECTION type. This is unsupported");
}
PG_FUNCTION_INFO_V1(isvalid);
Datum isvalid(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
bool result;
Geometry *g1;
initGEOS(MAXIMUM_ALIGNOF);
g1 = POSTGIS2GEOS(geom1 );
result = GEOSisvalid(g1);
GEOSdeleteGeometry(g1);
if (result == 2)
{
elog(ERROR,"GEOS isvalid() threw an error!");
PG_RETURN_NULL(); //never get here
}
PG_RETURN_BOOL(result);
}
// overlaps(GEOMETRY g1,GEOMETRY g2)
// returns if GEOS::g1->overlaps(g2) returns true
// throws an error (elog(ERROR,...)) if GEOS throws an error
PG_FUNCTION_INFO_V1(overlaps);
Datum overlaps(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
GEOMETRY *geom2 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
Geometry *g1,*g2;
bool result;
errorIfGeometryCollection(geom1,geom2);
initGEOS(MAXIMUM_ALIGNOF);
g1 = POSTGIS2GEOS(geom1 );
g2 = POSTGIS2GEOS(geom2 );
result = GEOSrelateOverlaps(g1,g2);
GEOSdeleteGeometry(g1);
GEOSdeleteGeometry(g2);
if (result == 2)
{
elog(ERROR,"GEOS overlaps() threw an error!");
PG_RETURN_NULL(); //never get here
}
PG_RETURN_BOOL(result);
}
PG_FUNCTION_INFO_V1(contains);
Datum contains(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
GEOMETRY *geom2 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
Geometry *g1,*g2;
bool result;
errorIfGeometryCollection(geom1,geom2);
initGEOS(MAXIMUM_ALIGNOF);
g1 = POSTGIS2GEOS(geom1 );
g2 = POSTGIS2GEOS(geom2 );
result = GEOSrelateContains(g1,g2);
GEOSdeleteGeometry(g1);
GEOSdeleteGeometry(g2);
if (result == 2)
{
elog(ERROR,"GEOS contains() threw an error!");
PG_RETURN_NULL(); //never get here
}
PG_RETURN_BOOL(result);
}
PG_FUNCTION_INFO_V1(within);
Datum within(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
GEOMETRY *geom2 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
Geometry *g1,*g2;
bool result;
errorIfGeometryCollection(geom1,geom2);
initGEOS(MAXIMUM_ALIGNOF);
g1 = POSTGIS2GEOS(geom1 );
g2 = POSTGIS2GEOS(geom2 );
result = GEOSrelateWithin(g1,g2);
GEOSdeleteGeometry(g1);
GEOSdeleteGeometry(g2);
if (result == 2)
{
elog(ERROR,"GEOS within() threw an error!");
PG_RETURN_NULL(); //never get here
}
PG_RETURN_BOOL(result);
}
PG_FUNCTION_INFO_V1(crosses);
Datum crosses(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
GEOMETRY *geom2 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
Geometry *g1,*g2;
bool result;
errorIfGeometryCollection(geom1,geom2);
initGEOS(MAXIMUM_ALIGNOF);
g1 = POSTGIS2GEOS(geom1 );
g2 = POSTGIS2GEOS(geom2 );
result = GEOSrelateCrosses(g1,g2);
GEOSdeleteGeometry(g1);
GEOSdeleteGeometry(g2);
if (result == 2)
{
elog(ERROR,"GEOS crosses() threw an error!");
PG_RETURN_NULL(); //never get here
}
PG_RETURN_BOOL(result);
}
PG_FUNCTION_INFO_V1(intersects);
Datum intersects(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
GEOMETRY *geom2 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
Geometry *g1,*g2;
bool result;
errorIfGeometryCollection(geom1,geom2);
initGEOS(MAXIMUM_ALIGNOF);
g1 = POSTGIS2GEOS(geom1 );
g2 = POSTGIS2GEOS(geom2 );
result = GEOSrelateIntersects(g1,g2);
GEOSdeleteGeometry(g1);
GEOSdeleteGeometry(g2);
if (result == 2)
{
elog(ERROR,"GEOS intersects() threw an error!");
PG_RETURN_NULL(); //never get here
}
PG_RETURN_BOOL(result);
}
PG_FUNCTION_INFO_V1(touches);
Datum touches(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
GEOMETRY *geom2 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
Geometry *g1,*g2;
bool result;
errorIfGeometryCollection(geom1,geom2);
initGEOS(MAXIMUM_ALIGNOF);
g1 = POSTGIS2GEOS(geom1 );
g2 = POSTGIS2GEOS(geom2 );
result = GEOSrelateTouches(g1,g2);
GEOSdeleteGeometry(g1);
GEOSdeleteGeometry(g2);
if (result == 2)
{
elog(ERROR,"GEOS touches() threw an error!");
PG_RETURN_NULL(); //never get here
}
PG_RETURN_BOOL(result);
}
PG_FUNCTION_INFO_V1(disjoint);
Datum disjoint(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
GEOMETRY *geom2 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
Geometry *g1,*g2;
bool result;
errorIfGeometryCollection(geom1,geom2);
initGEOS(MAXIMUM_ALIGNOF);
g1 = POSTGIS2GEOS(geom1 );
g2 = POSTGIS2GEOS(geom2 );
result = GEOSrelateDisjoint(g1,g2);
GEOSdeleteGeometry(g1);
GEOSdeleteGeometry(g2);
if (result == 2)
{
elog(ERROR,"GEOS disjoin() threw an error!");
PG_RETURN_NULL(); //never get here
}
PG_RETURN_BOOL(result);
}
PG_FUNCTION_INFO_V1(relate_pattern);
Datum relate_pattern(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
GEOMETRY *geom2 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
char *patt;
bool result;
Geometry *g1,*g2;
errorIfGeometryCollection(geom1,geom2);
initGEOS(MAXIMUM_ALIGNOF);
g1 = POSTGIS2GEOS(geom1 );
g2 = POSTGIS2GEOS(geom2 );
patt = DatumGetCString(DirectFunctionCall1(textout,
PointerGetDatum(PG_GETARG_DATUM(2))));
result = GEOSrelatePattern(g1,g2,patt);
GEOSdeleteGeometry(g1);
GEOSdeleteGeometry(g2);
pfree(patt);
if (result == 2)
{
elog(ERROR,"GEOS relate_pattern() threw an error!");
PG_RETURN_NULL(); //never get here
}
PG_RETURN_BOOL(result);
}
PG_FUNCTION_INFO_V1(relate_full);
Datum relate_full(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
GEOMETRY *geom2 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
Geometry *g1,*g2;
char *relate_str;
int len;
char *result;
//elog(NOTICE,"in relate_full()");
errorIfGeometryCollection(geom1,geom2);
initGEOS(MAXIMUM_ALIGNOF);
//elog(NOTICE,"GEOS init()");
g1 = POSTGIS2GEOS(geom1 );
g2 = POSTGIS2GEOS(geom2 );
//elog(NOTICE,"constructed geometries ");
if ((g1==NULL) || (g2 == NULL))
elog(NOTICE,"g1 or g2 are null");
//elog(NOTICE,GEOSasText(g1));
//elog(NOTICE,GEOSasText(g2));
//elog(NOTICE,"valid g1 = %i", GEOSisvalid(g1));
//elog(NOTICE,"valid g2 = %i",GEOSisvalid(g2));
//elog(NOTICE,"about to relate()");
relate_str = GEOSrelate(g1, g2);
//elog(NOTICE,"finished relate()");
GEOSdeleteGeometry(g1);
GEOSdeleteGeometry(g2);
if (relate_str == NULL)
{
//free(relate_str);
elog(ERROR,"GEOS relate() threw an error!");
PG_RETURN_NULL(); //never get here
}
len = strlen(relate_str) + 4;
result= palloc(len);
*((int *) result) = len;
memcpy(result +4, relate_str, len-4);
free(relate_str);
PG_RETURN_POINTER(result);
}
//==============================
PG_FUNCTION_INFO_V1(geomequals);
Datum geomequals(PG_FUNCTION_ARGS)
{
GEOMETRY *geom1 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
GEOMETRY *geom2 = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
Geometry *g1,*g2;
bool result;
errorIfGeometryCollection(geom1,geom2);
initGEOS(MAXIMUM_ALIGNOF);
g1 = POSTGIS2GEOS(geom1 );
g2 = POSTGIS2GEOS(geom2 );
result = GEOSequals(g1,g2);
GEOSdeleteGeometry(g1);
GEOSdeleteGeometry(g2);
if (result == 2)
{
elog(ERROR,"GEOS equals() threw an error!");
PG_RETURN_NULL(); //never get here
}
PG_RETURN_BOOL(result);
}
PG_FUNCTION_INFO_V1(issimple);
Datum issimple(PG_FUNCTION_ARGS)
{
GEOMETRY *geom = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
Geometry *g1;
int result;
if (geom->nobjs == 0)
PG_RETURN_BOOL(true);
initGEOS(MAXIMUM_ALIGNOF);
//elog(NOTICE,"GEOS init()");
g1 = POSTGIS2GEOS(geom );
result = GEOSisSimple(g1);
GEOSdeleteGeometry(g1);
if (result == 2)
{
elog(ERROR,"GEOS issimple() threw an error!");
PG_RETURN_NULL(); //never get here
}
PG_RETURN_BOOL(result);
}
PG_FUNCTION_INFO_V1(isring);
Datum isring(PG_FUNCTION_ARGS)
{
GEOMETRY *geom = (GEOMETRY *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
Geometry *g1;
int result;
if (geom->type != LINETYPE)
{
elog(ERROR,"isring() should only be called on a LINE");
}
if (geom->nobjs == 0)
PG_RETURN_BOOL(false);
initGEOS(MAXIMUM_ALIGNOF);
//elog(NOTICE,"GEOS init()");
g1 = POSTGIS2GEOS(geom );
result = GEOSisRing(g1);
GEOSdeleteGeometry(g1);
if (result == 2)
{
elog(ERROR,"GEOS isring() threw an error!");
PG_RETURN_NULL(); //never get here
}
PG_RETURN_BOOL(result);
}
//===================================================
POLYGON3D *PolyFromGeometry(Geometry *g, int *size)
{
int ninteriorrings;
POINT3D *pts;
int *pts_per_ring;
int t;
POLYGON3D *poly;
int npoints;
ninteriorrings = GEOSGetNumInteriorRings(g);
npoints = GEOSGetNumCoordinate(g);
pts = GEOSGetCoordinates(g);
if (npoints <3)
{
GEOSdeleteChar( (char*) pts);
return NULL;
}
pts_per_ring = palloc(sizeof(int) * (ninteriorrings+1));
pts_per_ring[0] = GEOSGetNumCoordinate(GEOSGetExteriorRing(g));
for (t=0;tpoints[t].x,line->points[t].y,line->points[t].z);
//}
GEOSdeleteChar( (char*) pts);
return line;
}
GEOMETRY *GEOS2POSTGIS(Geometry *g,char want3d)
{
int type = GEOSGeometryTypeId(g) ;
GEOMETRY *result = NULL;
POINT3D *pts;
LINE3D *line;
BOX3D *bbox ;
GEOMETRY *geom, *g2, *r;
POLYGON3D *poly;
GEOMETRY *g_new,*g_old;
int ngeoms,t,size;
switch (type)
{
/* From slower to faster.. compensation rule :) */
case COLLECTIONTYPE:
#ifdef DEBUG_GEOS2POSTGIS
elog(NOTICE, "GEOS2POSTGIS: It's a COLLECTION");
#endif
//this is more difficult because GEOS allows GCs of GCs
ngeoms = GEOSGetNumGeometries(g);
if (ngeoms ==0)
{
result = makeNullGeometry(GEOSGetSRID(g));
return result;
}
if (ngeoms == 1)
{
return GEOS2POSTGIS(GEOSGetGeometryN(g,0),
want3d); // short cut!
}
geom = GEOS2POSTGIS(GEOSGetGeometryN(g,0) , want3d);
for (t=1;ttype = MULTIPOLYGONTYPE;
return result;
}
for (t=0;tbvol, bbox, sizeof(BOX3D) );
// free bounding box
pfree( bbox );
return result;
case MULTILINETYPE:
#ifdef DEBUG_GEOS2POSTGIS
elog(NOTICE, "GEOS2POSTGIS: It's a MULTILINE");
#endif
ngeoms = GEOSGetNumGeometries(g);
if (ngeoms ==0)
{
result = makeNullGeometry(GEOSGetSRID(g));
result->type = MULTILINETYPE;
return result;
}
line = LineFromGeometry(GEOSGetGeometryN(g,0), &size);
result = make_oneobj_geometry(size, (char *)line,
MULTILINETYPE, want3d,
GEOSGetSRID(g),1.0, 0.0, 0.0);
#ifdef DEBUG_GEOS2POSTGIS
elog(NOTICE,"GEOS2POSTGIS: t0: %s",geometry_to_text(result));
elog(NOTICE," size = %i", result->size);
#endif
for (t=1;tsize);
#endif
pfree(g_old);
}
bbox = bbox_of_geometry( result ); // make bounding box
memcpy( &result->bvol, bbox, sizeof(BOX3D) ); // copy bounding box
pfree( bbox ); // free bounding box
#ifdef DEBUG_GEOS2POSTGIS
elog(NOTICE,"GEOS2POSTGIS: end: %s",geometry_to_text(result));
elog(NOTICE," size = %i", result->size);
#endif
return result;
case MULTIPOINTTYPE:
#ifdef DEBUG_GEOS2POSTGIS
elog(NOTICE, "GEOS2POSTGIS: It's a MULTIPOINT");
#endif
g_new = NULL;
ngeoms = GEOSGetNumGeometries(g);
if (ngeoms ==0)
{
result = makeNullGeometry(GEOSGetSRID(g));
result->type = MULTIPOINTTYPE;
return result;
}
pts = GEOSGetCoordinates(g);
g_old = make_oneobj_geometry(sizeof(POINT3D),
(char *) pts, MULTIPOINTTYPE, want3d,
GEOSGetSRID(g),1.0, 0.0, 0.0);
for (t=1;tbvol, bbox, sizeof(BOX3D) );
// free bounding box
pfree( bbox );
return g_new;
case POLYGONTYPE:
#ifdef DEBUG_GEOS2POSTGIS
elog(NOTICE, "GEOS2POSTGIS: It's a POLYGON");
#endif
poly = PolyFromGeometry(g,&size);
if (poly == NULL) return NULL;
result = make_oneobj_geometry(size,
(char *) poly, POLYGONTYPE, want3d,
GEOSGetSRID(g),1.0, 0.0, 0.0);
return result;
case LINETYPE:
#ifdef DEBUG_GEOS2POSTGIS
elog(NOTICE, "GEOS2POSTGIS: It's a LINE");
#endif
line = LineFromGeometry(g,&size);
if (line == NULL) return NULL;
result = make_oneobj_geometry(size,
(char *) line, LINETYPE, want3d,
GEOSGetSRID(g),1.0, 0.0, 0.0);
return result;
case POINTTYPE:
#ifdef DEBUG_GEOS2POSTGIS
elog(NOTICE, "GEOS2POSTGIS: It's a POINT");
#endif
pts = GEOSGetCoordinate(g);
result = make_oneobj_geometry(sizeof(POINT3D),
(char *) pts, POINTTYPE, want3d,
GEOSGetSRID(g), 1.0, 0.0, 0.0);
GEOSdeleteChar( (char*) pts);
return result;
default:
#ifdef DEBUG_GEOS2POSTGIS
elog(NOTICE, "GEOS2POSTGIS: It's UNKNOWN!");
#endif
return NULL;
}
}
//BBOXONLYTYPE -> returns as a 2d polygon
Geometry *POSTGIS2GEOS(GEOMETRY *g)
{
POINT3D *pt;
LINE3D *line;
POLYGON3D *poly;
POLYGON3D **polys;
LINE3D **lines;
POINT3D **points;
Geometry **geoms;
Geometry *geos;
char *obj;
int obj_type;
int t;
Geometry *result;
int32 *offsets1 = (int32 *) ( ((char *) &(g->objType[0] ))+ sizeof(int32) * g->nobjs ) ;
switch(g->type)
{
case POINTTYPE:
#ifdef DEBUG_POSTGIS2GEOS
elog(NOTICE, "POSTGIS2GEOS: it's a POINT");
#endif
pt = (POINT3D*) ((char *) g +offsets1[0]) ;
result = PostGIS2GEOS_point(pt,g->SRID,g->is3d);
if (result == NULL)
{
elog(ERROR,"Couldnt convert the postgis geometry to GEOS!");
}
return result;
break;
case LINETYPE:
#ifdef DEBUG_POSTGIS2GEOS
elog(NOTICE, "POSTGIS2GEOS: it's a LINE");
#endif
line = (LINE3D*) ((char *) g +offsets1[0]) ;
result = PostGIS2GEOS_linestring(line,g->SRID,g->is3d);
if (result == NULL)
{
elog(ERROR,"Couldnt convert the postgis geometry to GEOS!");
}
return result;
break;
case POLYGONTYPE:
#ifdef DEBUG_POSTGIS2GEOS
elog(NOTICE, "POSTGIS2GEOS: it's a POLYGON");
#endif
poly = (POLYGON3D*) ((char *) g +offsets1[0]) ;
result = PostGIS2GEOS_polygon(poly,g->SRID,g->is3d);
if (result == NULL)
{
elog(ERROR,"Couldnt convert the postgis geometry to GEOS!");
}
return result;
break;
case MULTIPOLYGONTYPE:
#ifdef DEBUG_POSTGIS2GEOS
elog(NOTICE, "POSTGIS2GEOS: it's a MULTIPOLYGON");
#endif
//make an array of POLYGON3Ds
polys = NULL;
if (g->nobjs >0)
polys = (POLYGON3D**) palloc(sizeof (POLYGON3D*) * g->nobjs);
for (t=0;tnobjs;t++)
{
polys[t] = (POLYGON3D*) ((char *) g +offsets1[t]) ;
}
geos= PostGIS2GEOS_multipolygon(polys, g->nobjs, g->SRID,g->is3d);
if (polys != NULL) pfree(polys);
if (geos == NULL)
{
elog(ERROR,"Couldnt convert the postgis geometry to GEOS!");
}
return geos;
break;
case MULTILINETYPE:
#ifdef DEBUG_POSTGIS2GEOS
elog(NOTICE, "POSTGIS2GEOS: it's a MULTILINE");
#endif
//make an array of LINES3D
lines = NULL;
if (g->nobjs >0)
lines = (LINE3D**) palloc(sizeof (LINE3D*) * g->nobjs);
for (t=0;tnobjs;t++)
{
#ifdef DEBUG_POSTGIS2GEOS
elog(NOTICE, "Line %d has offset %d", t, offsets1[t]);
#endif
lines[t] = (LINE3D*) ((char *)g+offsets1[t]) ;
}
geos= PostGIS2GEOS_multilinestring(lines, g->nobjs, g->SRID,g->is3d);
if (lines != NULL) pfree(lines);
if (geos == NULL)
{
elog(ERROR,"Couldnt convert the postgis geometry to GEOS!");
}
return geos;
break;
case MULTIPOINTTYPE:
#ifdef DEBUG_POSTGIS2GEOS
elog(NOTICE, "POSTGIS2GEOS: it's a MULTIPOINT");
#endif
//make an array of POINT3Ds
points = NULL;
if (g->nobjs >0)
points = (POINT3D**) palloc(sizeof (POINT3D*) * g->nobjs);
for (t=0;tnobjs;t++)
{
points[t] = (POINT3D*) ((char *) g +offsets1[t]) ;
}
geos= PostGIS2GEOS_multipoint(points, g->nobjs,g->SRID,g->is3d);
if (points != NULL) pfree(points);
if (geos == NULL)
{
elog(ERROR,"Couldnt convert the postgis geometry to GEOS!");
}
return geos;
break;
case BBOXONLYTYPE:
#ifdef DEBUG_POSTGIS2GEOS
elog(NOTICE, "POSTGIS2GEOS: it's a BBOXONLY");
#endif
result = PostGIS2GEOS_box3d(&g->bvol, g->SRID);
if (result == NULL)
{
elog(ERROR,"Couldnt convert the postgis geometry to GEOS!");
}
return result;
break;
case COLLECTIONTYPE:
#ifdef DEBUG_POSTGIS2GEOS
elog(NOTICE, "POSTGIS2GEOS: it's a COLLECTION");
#endif
//make an array of GEOS Geometries
geoms = NULL;
if (g->nobjs >0)
geoms = (Geometry**) palloc(sizeof (Geometry*) * g->nobjs);
for (t=0;tnobjs;t++)
{
obj = ((char *) g +offsets1[t]);
obj_type = g->objType[t];
switch (obj_type)
{
case POINTTYPE:
pt = (POINT3D*) obj ;
geoms[t] = PostGIS2GEOS_point(pt,g->SRID,g->is3d);
if (geoms[t] == NULL)
{
pfree(geoms);
elog(ERROR,"Couldnt convert the postgis geometry to GEOS!");
return NULL;
}
break;
case LINETYPE:
line = (LINE3D*) obj ;
geoms[t] = PostGIS2GEOS_linestring(line,g->SRID,g->is3d);
if (geoms[t] == NULL)
{
pfree(geoms);
elog(ERROR,"Couldnt convert the postgis geometry to GEOS!");
return NULL;
}
break;
case POLYGONTYPE:
poly = (POLYGON3D*) obj ;
geoms[t] = PostGIS2GEOS_polygon(poly,g->SRID,g->is3d);
if (geoms[t] == NULL)
{
pfree(geoms);
elog(ERROR,"Couldnt convert the postgis geometry to GEOS!");
return NULL;
}
break;
}
}
#ifdef DEBUG_POSTGIS2GEOS
elog(NOTICE, "POSTGIS2GEOS: COLLECTION has %d objs, srid %d and is %s 3d", g->nobjs, g->SRID, g->is3d ? "" : "not");
#endif
geos = PostGIS2GEOS_collection(geoms,g->nobjs,g->SRID,g->is3d);
if (geoms != NULL) pfree(geoms);
if (geos == NULL)
{
elog(ERROR,"Couldnt convert the postgis geometry to GEOS!");
}
return geos;
break;
}
return NULL;
}
PG_FUNCTION_INFO_V1(GEOSnoop);
Datum GEOSnoop(PG_FUNCTION_ARGS)
{
GEOMETRY *geom;
Geometry *geosgeom;
GEOMETRY *result;
initGEOS(MAXIMUM_ALIGNOF);
geom = (GEOMETRY *)PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
#ifdef DEBUG_CONVERTER
elog(NOTICE, "GEOSnoop: IN: %s", geometry_to_text(geom));
#endif
geosgeom = POSTGIS2GEOS(geom);
if ( (Pointer *)geom != (Pointer *)PG_GETARG_DATUM(0) ) pfree(geom);
result = GEOS2POSTGIS(geosgeom, geom->is3d);
GEOSdeleteGeometry(geosgeom);
#ifdef DEBUG_CONVERTER
elog(NOTICE, "GEOSnoop: OUT: %s", geometry_to_text(result));
#endif
PG_RETURN_POINTER(result);
}
//----------------------------------------------------------------------------
// NULL implementation here
// ---------------------------------------------------------------------------
#else // ndef USE_GEOS
#include "postgres.h"
#include
#include
#include
#include
#include
#include "fmgr.h"
Datum relate_full(PG_FUNCTION_ARGS);
Datum relate_pattern(PG_FUNCTION_ARGS);
Datum disjoint(PG_FUNCTION_ARGS);
Datum touches(PG_FUNCTION_ARGS);
Datum intersects(PG_FUNCTION_ARGS);
Datum crosses(PG_FUNCTION_ARGS);
Datum within(PG_FUNCTION_ARGS);
Datum contains(PG_FUNCTION_ARGS);
Datum overlaps(PG_FUNCTION_ARGS);
Datum isvalid(PG_FUNCTION_ARGS);
Datum buffer(PG_FUNCTION_ARGS);
Datum intersection(PG_FUNCTION_ARGS);
Datum convexhull(PG_FUNCTION_ARGS);
Datum difference(PG_FUNCTION_ARGS);
Datum boundary(PG_FUNCTION_ARGS);
Datum symdifference(PG_FUNCTION_ARGS);
Datum geomunion(PG_FUNCTION_ARGS);
PG_FUNCTION_INFO_V1(intersection);
Datum intersection(PG_FUNCTION_ARGS)
{
elog(ERROR,"intersection:: operation not implemented - compile PostGIS with GEOS support");
PG_RETURN_NULL(); // never get here
}
PG_FUNCTION_INFO_V1(convexhull);
Datum convexhull(PG_FUNCTION_ARGS)
{
elog(ERROR,"convexhull:: operation not implemented - compile PostGIS with GEOS support");
PG_RETURN_NULL(); // never get here
}
PG_FUNCTION_INFO_V1(difference);
Datum difference(PG_FUNCTION_ARGS)
{
elog(ERROR,"difference:: operation not implemented - compile PostGIS with GEOS support");
PG_RETURN_NULL(); // never get here
}
PG_FUNCTION_INFO_V1(boundary);
Datum boundary(PG_FUNCTION_ARGS)
{
elog(ERROR,"boundary:: operation not implemented - compile PostGIS with GEOS support");
PG_RETURN_NULL(); // never get here
}
PG_FUNCTION_INFO_V1(symdifference);
Datum symdifference(PG_FUNCTION_ARGS)
{
elog(ERROR,"symdifference:: operation not implemented - compile PostGIS with GEOS support");
PG_RETURN_NULL(); // never get here
}
PG_FUNCTION_INFO_V1(geomunion);
Datum geomunion(PG_FUNCTION_ARGS)
{
elog(ERROR,"geomunion:: operation not implemented - compile PostGIS with GEOS support");
PG_RETURN_NULL(); // never get here
}
PG_FUNCTION_INFO_V1(buffer);
Datum buffer(PG_FUNCTION_ARGS)
{
elog(ERROR,"buffer:: operation not implemented - compile PostGIS with GEOS support");
PG_RETURN_NULL(); // never get here
}
PG_FUNCTION_INFO_V1(relate_full);
Datum relate_full(PG_FUNCTION_ARGS)
{
elog(ERROR,"relate_full:: operation not implemented - compile PostGIS with GEOS support");
PG_RETURN_NULL(); // never get here
}
PG_FUNCTION_INFO_V1(relate_pattern);
Datum relate_pattern(PG_FUNCTION_ARGS)
{
elog(ERROR,"relate_pattern:: operation not implemented - compile PostGIS with GEOS support");
PG_RETURN_NULL(); // never get here
}
PG_FUNCTION_INFO_V1(disjoint);
Datum disjoint(PG_FUNCTION_ARGS)
{
elog(ERROR,"disjoint:: operation not implemented - compile PostGIS with GEOS support");
PG_RETURN_NULL(); // never get here
}
PG_FUNCTION_INFO_V1(intersects);
Datum intersects(PG_FUNCTION_ARGS)
{
elog(ERROR,"intersects:: operation not implemented - compile PostGIS with GEOS support");
PG_RETURN_NULL(); // never get here
}
PG_FUNCTION_INFO_V1(touches);
Datum touches(PG_FUNCTION_ARGS)
{
elog(ERROR,"touches:: operation not implemented - compile PostGIS with GEOS support");
PG_RETURN_NULL(); // never get here
}
PG_FUNCTION_INFO_V1(crosses);
Datum crosses(PG_FUNCTION_ARGS)
{
elog(ERROR,"crosses:: operation not implemented - compile PostGIS with GEOS support");
PG_RETURN_NULL(); // never get here
}
PG_FUNCTION_INFO_V1(within);
Datum within(PG_FUNCTION_ARGS)
{
elog(ERROR,"within:: operation not implemented - compile PostGIS with GEOS support");
PG_RETURN_NULL(); // never get here
}
PG_FUNCTION_INFO_V1(contains);
Datum contains(PG_FUNCTION_ARGS)
{
elog(ERROR,"contains:: operation not implemented - compile PostGIS with GEOS support");
PG_RETURN_NULL(); // never get here
}
PG_FUNCTION_INFO_V1(overlaps);
Datum overlaps(PG_FUNCTION_ARGS)
{
elog(ERROR,"overlaps:: operation not implemented - compile PostGIS with GEOS support");
PG_RETURN_NULL(); // never get here
}
PG_FUNCTION_INFO_V1(isvalid);
Datum isvalid(PG_FUNCTION_ARGS)
{
elog(ERROR,"isvalid:: operation not implemented - compile PostGIS with GEOS support");
PG_RETURN_NULL(); // never get here
}
PG_FUNCTION_INFO_V1(issimple);
Datum issimple(PG_FUNCTION_ARGS)
{
elog(ERROR,"issimple:: operation not implemented - compile PostGIS with GEOS support");
PG_RETURN_NULL(); // never get here
}
PG_FUNCTION_INFO_V1(geomequals);
Datum geomequals(PG_FUNCTION_ARGS)
{
elog(ERROR,"geomequals:: operation not implemented - compile PostGIS with GEOS support");
PG_RETURN_NULL(); // never get here
}
PG_FUNCTION_INFO_V1(isring);
Datum isring(PG_FUNCTION_ARGS)
{
elog(ERROR,"isring:: operation not implemented - compile PostGIS with GEOS support");
PG_RETURN_NULL(); // never get here
}
PG_FUNCTION_INFO_V1(pointonsurface);
Datum pointonsurface(PG_FUNCTION_ARGS)
{
elog(ERROR,"pointonsurface:: operation not implemented - compile PostGIS with GEOS support");
PG_RETURN_NULL(); // never get here
}
PG_FUNCTION_INFO_V1(unite_garray);
Datum unite_garray(PG_FUNCTION_ARGS)
{
elog(ERROR,"unite_garray:: operation not implemented - compile PostGIS with GEOS support");
PG_RETURN_NULL(); // never get here
}
PG_FUNCTION_INFO_V1(GEOSnoop);
Datum GEOSnoop(PG_FUNCTION_ARGS)
{
elog(ERROR,"GEOSnoop:: operation not implemented - compile PostGIS with GEOS support");
PG_RETURN_NULL();
}
#endif
postgis-0.8.1/postgis_geos_wrapper.cpp 0100664 0000773 0000144 00000063332 07766341734 017627 0 ustar postgis users // g++ postgis_GEOSwrapper.cpp -c -I/usr/local/include -I/usr/local/include/geos -I/usr/local/src/postgresql-7.2.3//src/include
/*
* $Log: postgis_geos_wrapper.cpp,v $
* Revision 1.17 2025/12/12 13:34:20 strk
* added missing 'const' in prototypes
*
* Revision 1.16 2025/12/12 12:03:30 strk
* More debugging output, some code cleanup.
*
* Revision 1.15 2025/11/12 16:36:04 strk
* delete all caught exceptions after use
*
* Revision 1.14 2025/10/29 13:58:28 strk
* Added GEOSGetCentroid() function
*
* Revision 1.13 2025/10/24 21:33:21 strk
* Added GEOSGeometryTypeId(Geometry *) wrapper function.
* Added GEOSGetCoordinates_Polygon(Polygon *) as an experimental optimized
* version of GEOSGetCoordinates(Geometry *); More to add ...
*
* Revision 1.12 2025/10/24 14:29:53 strk
* GEOSGetCoordinates() reverted to getCoordinates() call so to be compatible
* to all type of geometries (not only LineStrings)
*
* Revision 1.11 2025/10/24 08:28:50 strk
* Fixed memory leak in GEOSGetCoordinates(), made sure that GEOS2POSTGIS
* free type string even in case of collapsed geoms. Made sure that geomunion
* release memory in case of exception thrown by GEOSUnion. Sooner release
* of palloced memory in PolyFromGeometry (pts_per_ring).
*
* Revision 1.10 2025/10/20 19:50:49 strk
* Removed some memory leaks in PostGIS2* converters.
*
*/
#include
#include
#include
#include
#include "geom.h"
#include "util.h"
using namespace geos;
//WARNING THIS *MUST* BE SET CORRECTLY.
int MAXIMUM_ALIGNOF = -999999; // to be set during initialization - this will be either 4 (intel) or 8 (sparc)
//for getting things to align properly double are on 8byte align on solaris machines, and 4bytes on intel
#define TYPEALIGN(ALIGNVAL,LEN) (((long)(LEN) + (ALIGNVAL-1)) & ~(ALIGNVAL-1))
#define MAXALIGN(LEN) TYPEALIGN(MAXIMUM_ALIGNOF, (LEN))
typedef int int32;
typedef struct
{
double x,y,z; //for lat/long x=long, y=lat
} POINT3D;
typedef struct
{
POINT3D LLB,URT; /* corner POINT3Ds on long diagonal */
} BOX3D;
typedef struct
{
int32 npoints; // how many points in the line
int32 junk; // double-word alignment
POINT3D points[1]; // array of actual points
} LINE3D;
typedef struct
{
int32 nrings; // how many rings in this polygon
int32 npoints[1]; //how many points in each ring
/* could be 4 byes of filler here to make sure points[] is
double-word aligned*/
POINT3D points[1]; // array of actual points
} POLYGON3D;
#define POINTTYPE 1
#define LINETYPE 2
#define POLYGONTYPE 3
#define MULTIPOINTTYPE 4
#define MULTILINETYPE 5
#define MULTIPOLYGONTYPE 6
#define COLLECTIONTYPE 7
//###########################################################
extern "C" char *GEOSrelate(Geometry *g1, Geometry*g2);
extern "C" void initGEOS(int maxalign);
extern "C" void GEOSdeleteChar(char *a);
extern "C" void GEOSdeleteGeometry(Geometry *a);
extern "C" char GEOSrelatePattern(Geometry *g1, Geometry*g2,char *pat);
extern "C" char GEOSrelateDisjoint(Geometry *g1, Geometry*g2);
extern "C" char GEOSrelateTouches(Geometry *g1, Geometry*g2);
extern "C" char GEOSrelateIntersects(Geometry *g1, Geometry*g2);
extern "C" char GEOSrelateCrosses(Geometry *g1, Geometry*g2);
extern "C" char GEOSrelateWithin(Geometry *g1, Geometry*g2);
extern "C" char GEOSrelateContains(Geometry *g1, Geometry*g2);
extern "C" char GEOSrelateOverlaps(Geometry *g1, Geometry*g2);
extern "C" Geometry *PostGIS2GEOS_point(POINT3D *point,int SRID, bool is3d);
extern "C" Geometry *PostGIS2GEOS_linestring(const LINE3D *line,int SRID, bool is3d);
extern "C" Geometry *PostGIS2GEOS_polygon(POLYGON3D *polygon,int SRID, bool is3d);
extern "C" Geometry *PostGIS2GEOS_multipolygon(POLYGON3D **polygons,int npolys, int SRID, bool is3d);
extern "C" Geometry *PostGIS2GEOS_multilinestring(const LINE3D **lines,int nlines, int SRID, bool is3d);
extern "C" Geometry *PostGIS2GEOS_multipoint(POINT3D **points,int npoints, int SRID, bool is3d);
extern "C" Geometry *PostGIS2GEOS_box3d(BOX3D *box, int SRID);
extern "C" Geometry *PostGIS2GEOS_collection(Geometry **geoms, int ngeoms,int SRID, bool is3d);
extern "C" char GEOSisvalid(Geometry *g1);
extern "C" char *GEOSasText(Geometry *g1);
extern "C" char GEOSisEmpty(Geometry *g1);
extern "C" char *GEOSGeometryType(Geometry *g1);
extern "C" int GEOSGeometryTypeId(Geometry *g1);
extern "C" char *throw_exception(Geometry *g);
extern "C" Geometry *GEOSIntersection(Geometry *g1,Geometry *g1);
extern "C" Geometry *GEOSBuffer(Geometry *g1,double width);
extern "C" Geometry *GEOSConvexHull(Geometry *g1);
extern "C" Geometry *GEOSDifference(Geometry *g1,Geometry *g2);
extern "C" Geometry *GEOSBoundary(Geometry *g1);
extern "C" Geometry *GEOSSymDifference(Geometry *g1,Geometry *g2);
extern "C" Geometry *GEOSUnion(Geometry *g1,Geometry *g2);
extern "C" POINT3D *GEOSGetCoordinate(Geometry *g1);
extern "C" POINT3D *GEOSGetCoordinates_Polygon(Polygon *g1);
extern "C" POINT3D *GEOSGetCoordinates(Geometry *g1);
extern "C" int GEOSGetNumCoordinate(Geometry *g1);
extern "C" const Geometry *GEOSGetGeometryN(Geometry *g1, int n);
extern "C" const Geometry *GEOSGetExteriorRing(Geometry *g1);
extern "C" const Geometry *GEOSGetInteriorRingN(Geometry *g1, int n);
extern "C" int GEOSGetNumInteriorRings(Geometry *g1);
extern "C" int GEOSGetSRID(Geometry *g1);
extern "C" int GEOSGetNumGeometries(Geometry *g1);
extern "C" char GEOSisSimple(Geometry *g1);
extern "C" char GEOSequals(Geometry *g1, Geometry*g2);
extern "C" char GEOSisRing(Geometry *g1);
extern "C" Geometry *GEOSpointonSurface(Geometry *g1);
extern "C" Geometry *GEOSGetCentroid(Geometry *g1);
extern "C" void NOTICE_MESSAGE(char *msg);
//###########################################################
GeometryFactory *geomFactory = NULL;
void initGEOS (int maxalign)
{
if (geomFactory == NULL)
{
geomFactory = new GeometryFactory( new PrecisionModel(), -1); // NOTE: SRID will have to be changed after geometry creation
MAXIMUM_ALIGNOF = maxalign;
}
}
// ------------------------------------------------------------------------------
// geometry constuctors - return NULL if there was an error
//-------------------------------------------------------------------------------
//note: you lose the 3d from this!
Geometry *PostGIS2GEOS_box3d(BOX3D *box, int SRID)
{
try {
Geometry *g;
Envelope *envelope = new Envelope(box->LLB.x,box->URT.x ,box->LLB.y,box->URT.y);
g = geomFactory->toGeometry(envelope,geomFactory->getPrecisionModel(), SRID);
delete envelope;
if (g==NULL)
return NULL;
g->setSRID(SRID);
return g;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return NULL;
}
catch (...)
{
return NULL;
}
}
Geometry *PostGIS2GEOS_collection(Geometry **geoms, int ngeoms,int SRID, bool is3d)
{
try
{
Geometry *g;
int t;
vector *subGeos=new vector;
for (t =0; t< ngeoms; t++)
{
subGeos->push_back(geoms[t]);
}
g = geomFactory->buildGeometry(subGeos);
delete subGeos;
if (g==NULL)
return NULL;
g->setSRID(SRID);
return g;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return NULL;
}
catch (...)
{
return NULL;
}
}
Geometry *PostGIS2GEOS_point(POINT3D *point,int SRID, bool is3d)
{
try
{
Coordinate *c;
if (is3d)
c = new Coordinate(point->x, point->y);
else
c = new Coordinate(point->x, point->y, point->z);
Geometry *g = geomFactory->createPoint(*c);
delete c;
if (g==NULL)
return NULL;
g->setSRID(SRID);
return g;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return NULL;
}
catch (...)
{
return NULL;
}
}
/*
* This function must return an all-new allocated object
*/
Geometry *
PostGIS2GEOS_linestring(const LINE3D *line,int SRID, bool is3d)
{
try{
int t;
Coordinate c;
//build coordinatelist & pre-allocate space
BasicCoordinateList *coords = new BasicCoordinateList(line->npoints);
if (is3d)
{
for (t=0;tnpoints;t++)
{
c.x = line->points[t].x;
c.y = line->points[t].y;
c.z = line->points[t].z;
coords->setAt( c ,t);
}
}
else //make 2d points
{
for (t=0;tnpoints;t++)
{
c.x = line->points[t].x;
c.y = line->points[t].y;
c.z = DoubleNotANumber;
coords->setAt( c ,t);
}
}
Geometry *g = geomFactory->createLineString(coords);
delete coords;
if (g==NULL) return NULL;
g->setSRID(SRID);
return g;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return NULL;
}
catch (...)
{
return NULL;
}
}
//polygons is an array of pointers to polygons
Geometry *PostGIS2GEOS_multipolygon(POLYGON3D **polygons,int npolys, int SRID, bool is3d)
{
try
{
int t;
vector *subPolys=NULL;
Geometry *g;
subPolys=new vector;
for (t =0; t< npolys; t++)
{
subPolys->push_back(PostGIS2GEOS_polygon(polygons[t], SRID,is3d ));
}
g = geomFactory->createMultiPolygon(subPolys);
delete subPolys;
if (g== NULL)
return NULL;
g->setSRID(SRID);
return g;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return NULL;
}
catch (...)
{
return NULL;
}
}
//lines is an array of pointers to line3d
Geometry *
PostGIS2GEOS_multilinestring(const LINE3D **lines, int nlines, int SRID, bool is3d)
{
try
{
int t;
vector *subLines = new vector;
Geometry *g;
for (t =0; t< nlines; t++)
{
subLines->push_back(PostGIS2GEOS_linestring(lines[t],
SRID,is3d ));
}
// geometries pointed to by subLines will be owned
// by returned MultiLineString object
g = geomFactory->createMultiLineString(subLines);
delete subLines;
if (g==NULL) return NULL;
g->setSRID(SRID);
return g;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return NULL;
}
catch (...)
{
return NULL;
}
}
Geometry *PostGIS2GEOS_multipoint(POINT3D **points,int npoints, int SRID, bool is3d)
{
try
{
int t;
vector *subPoints =new vector;
Geometry *g;
for (t =0; t< npoints; t++)
{
subPoints->push_back(PostGIS2GEOS_point(points[t], SRID,is3d ));
}
g = geomFactory->createMultiPoint(subPoints);
delete subPoints;
if (g==NULL)
return NULL;
g->setSRID(SRID);
return g;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return NULL;
}
catch (...)
{
return NULL;
}
}
Geometry *PostGIS2GEOS_polygon(POLYGON3D *polygon,int SRID, bool is3d)
{
try
{
POINT3D *pts;
Coordinate c;
int ring,t;
Geometry *g;
LinearRing *outerRing;
LinearRing *innerRing;
BasicCoordinateList *cl;
int pointOffset =0; // first point that we're looking at. a POLYGON3D has all its points smooshed together
vector *innerRings=new vector;
pts = (POINT3D *) ( (char *)&(polygon->npoints[polygon->nrings] ) );
pts = (POINT3D *) MAXALIGN(pts);
// make outerRing
cl = new BasicCoordinateList(polygon->npoints[0]);
if (is3d)
{
for(t=0;tnpoints[0];t++)
{
c.x = pts[t].x;
c.y = pts[t].y;
c.z = pts[t].z;
cl->setAt( c ,t);
}
}
else
{
for(t=0;tnpoints[0];t++)
{
c.x = pts[t].x;
c.y = pts[t].y;
c.z = DoubleNotANumber;
cl->setAt( c ,t);
}
}
outerRing = (LinearRing*) geomFactory->createLinearRing(cl);
delete cl;
if (outerRing == NULL)
return NULL;
outerRing->setSRID(SRID);
pointOffset = polygon->npoints[0];
for(ring =1; ring< polygon->nrings; ring++)
{
cl = new BasicCoordinateList(polygon->npoints[ring]);
if (is3d)
{
for(t=0;tnpoints[ring];t++)
{
c.x = pts[t+pointOffset].x;
c.y = pts[t+pointOffset].y;
c.z = pts[t+pointOffset].z;
cl->setAt( c ,t);
}
}
else
{
for(t=0;tnpoints[ring];t++)
{
c.x = pts[t+pointOffset].x;
c.y = pts[t+pointOffset].y;
c.z = DoubleNotANumber;
cl->setAt( c ,t);
}
}
innerRing = (LinearRing *) geomFactory->createLinearRing(cl);
delete cl;
if (innerRing == NULL)
{
delete outerRing;
return NULL;
}
innerRing->setSRID(SRID);
innerRings->push_back(innerRing);
pointOffset += polygon->npoints[ring];
}
g = geomFactory->createPolygon(outerRing, innerRings);
if (g==NULL)
return NULL;
g->setSRID(SRID);
return g;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return NULL;
}
catch (...)
{
return NULL;
}
}
//-----------------------------------------------------------
// relate()-related functions
// return 0 = false, 1 = true, 2 = error occured
//-----------------------------------------------------------
char GEOSrelateDisjoint(Geometry *g1, Geometry*g2)
{
try {
bool result;
result = g1->disjoint(g2);
return result;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return 2;
}
catch (...)
{
return 2;
}
}
char GEOSrelateTouches(Geometry *g1, Geometry*g2)
{
try {
bool result;
result = g1->touches(g2);
return result;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return 2;
}
catch (...)
{
return 2;
}
}
char GEOSrelateIntersects(Geometry *g1, Geometry*g2)
{
try {
bool result;
result = g1->intersects(g2);
return result;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return 2;
}
catch (...)
{
return 2;
}
}
char GEOSrelateCrosses(Geometry *g1, Geometry*g2)
{
try {
bool result;
result = g1->crosses(g2);
return result;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return 2;
}
catch (...)
{
return 2;
}
}
char GEOSrelateWithin(Geometry *g1, Geometry*g2)
{
try {
bool result;
result = g1->within(g2);
return result;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return 2;
}
catch (...)
{
return 2;
}
}
// call g1->contains(g2)
// returns 0 = false
// 1 = true
// 2 = error was trapped
char GEOSrelateContains(Geometry *g1, Geometry*g2)
{
try {
bool result;
result = g1->contains(g2);
return result;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return 2;
}
catch (...)
{
return 2;
}
}
char GEOSrelateOverlaps(Geometry *g1, Geometry*g2)
{
try {
bool result;
result = g1->overlaps(g2);
return result;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return 2;
}
catch (...)
{
return 2;
}
}
//-------------------------------------------------------------------
// low-level relate functions
//------------------------------------------------------------------
char GEOSrelatePattern(Geometry *g1, Geometry*g2,char *pat)
{
try {
bool result;
string s = pat;
result = g1->relate(g2,pat);
return result;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return 2;
}
catch (...)
{
return 2;
}
}
char *GEOSrelate(Geometry *g1, Geometry*g2)
{
try {
IntersectionMatrix *im = g1->relate(g2);
string s;
char *result;
if (im == NULL)
return NULL;
s= im->toString();
result = (char*) malloc( s.length() + 1);
strcpy(result, s.c_str() );
return result;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return NULL;
}
catch (...)
{
return NULL;
}
}
//-----------------------------------------------------------------
// isValid
//-----------------------------------------------------------------
char GEOSisvalid(Geometry *g1)
{
try {
bool result;
result =g1->isValid();
return result;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return 2;
}
catch (...)
{
return 2;
}
}
//-----------------------------------------------------------------
// general purpose
//-----------------------------------------------------------------
char GEOSequals(Geometry *g1, Geometry*g2)
{
try {
bool result;
result = g1->equals(g2);
return result;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return 2;
}
catch (...)
{
return 2;
}
}
char *GEOSasText(Geometry *g1)
{
try
{
string s = g1->toString();
char *result;
result = (char*) malloc( s.length() + 1);
strcpy(result, s.c_str() );
return result;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return NULL;
}
catch (...)
{
return NULL;
}
}
char GEOSisEmpty(Geometry *g1)
{
try
{
return g1->isEmpty();
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return 2;
}
catch (...)
{
return 2;
}
}
char GEOSisSimple(Geometry *g1)
{
try
{
return g1->isSimple();
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return 2;
}
catch (...)
{
return 2;
}
}
char GEOSisRing(Geometry *g1)
{
try
{
return (( (LinearRing*)g1)->isRing());
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return 2;
}
catch (...)
{
return 2;
}
}
//free the result of this
char *GEOSGeometryType(Geometry *g1)
{
try
{
string s = g1->getGeometryType();
char *result;
result = (char*) malloc( s.length() + 1);
strcpy(result, s.c_str() );
return result;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return NULL;
}
catch (...)
{
return NULL;
}
}
// Return postgis geometry type index
int GEOSGeometryTypeId(Geometry *g1)
{
try
{
GeometryTypeId id = g1->getGeometryTypeId();
switch (id)
{
case GEOS_POINT:
return POINTTYPE;
case GEOS_LINESTRING:
return LINETYPE;
case GEOS_POLYGON:
return POLYGONTYPE;
case GEOS_MULTIPOINT:
return MULTIPOINTTYPE;
case GEOS_MULTILINESTRING:
return MULTILINETYPE;
case GEOS_MULTIPOLYGON:
return MULTIPOLYGONTYPE;
case GEOS_GEOMETRYCOLLECTION:
return COLLECTIONTYPE;
default:
return 0;
}
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return -1;
}
catch (...)
{
return -1;
}
}
//-------------------------------------------------------------------
// GEOS functions that return geometries
//-------------------------------------------------------------------
Geometry *GEOSIntersection(Geometry *g1,Geometry *g2)
{
try
{
Geometry *g3 = g1->intersection(g2);
return g3;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return NULL;
}
catch (...)
{
return NULL;
}
}
Geometry *GEOSBuffer(Geometry *g1,double width)
{
try
{
Geometry *g3 = g1->buffer(width);
return g3;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return NULL;
}
catch (...)
{
return NULL;
}
}
Geometry *GEOSConvexHull(Geometry *g1)
{
try
{
Geometry *g3 = g1->convexHull();
return g3;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return NULL;
}
catch (...)
{
return NULL;
}
}
Geometry *GEOSDifference(Geometry *g1,Geometry *g2)
{
try
{
Geometry *g3 = g1->difference(g2);
return g3;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return NULL;
}
catch (...)
{
return NULL;
}
}
Geometry *GEOSBoundary(Geometry *g1)
{
try
{
Geometry *g3 = g1->getBoundary();
return g3;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return NULL;
}
catch (...)
{
return NULL;
}
}
Geometry *GEOSSymDifference(Geometry *g1,Geometry *g2)
{
try
{
Geometry *g3 = g1->symDifference(g2);
return g3;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return NULL;
}
catch (...)
{
return NULL;
}
}
Geometry *GEOSUnion(Geometry *g1,Geometry *g2)
{
try
{
Geometry *g3 = g1->Union(g2);
return g3;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return NULL;
}
catch (...)
{
return NULL;
}
}
Geometry *GEOSpointonSurface(Geometry *g1)
{
try
{
Geometry *g3 = g1->getInteriorPoint();
return g3;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return NULL;
}
catch (...)
{
return NULL;
}
}
//-------------------------------------------------------------------
// memory management functions
//------------------------------------------------------------------
//BUG:: this leaks memory, but delete kills the PrecisionModel for ALL the geometries
void GEOSdeleteGeometry(Geometry *a)
{
try{
delete a;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
//return NULL;
}
catch(...)
{
// do nothing!
}
}
void GEOSdeleteChar(char *a)
{
try{
free(a);
}
catch (GEOSException *ge) // ???
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
//return NULL;
}
catch(...)
{
// do nothing!
}
}
//-------------------------------------------------------------------
//GEOS => POSTGIS conversions
//-------------------------------------------------------------------
// free the result when done!
// g1 must be a point
POINT3D *GEOSGetCoordinate(Geometry *g1)
{
try{
POINT3D *result = (POINT3D*) malloc (sizeof(POINT3D));
const Coordinate *c =g1->getCoordinate();
result->x = c->x;
result->y = c->y;
result->z = c->z;
return result;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return NULL;
}
catch(...)
{
return NULL;
}
}
//must free the result when done
// result is an array length g1->getNumCoordinates()
POINT3D *GEOSGetCoordinates(Geometry *g1)
{
if ( g1->getGeometryTypeId() == GEOS_POLYGON )
{
return GEOSGetCoordinates_Polygon((Polygon *)g1);
}
try {
int numPoints = g1->getNumPoints();
POINT3D *result = (POINT3D*) malloc (sizeof(POINT3D) * numPoints );
int t;
CoordinateList *cl = g1->getCoordinates();
Coordinate c;
for (t=0;tgetAt(t);
result[t].x = c.x;
result[t].y = c.y;
result[t].z = c.z;
}
delete cl;
return result;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return NULL;
}
catch(...)
{
return NULL;
}
}
// A somewhat optimized version for polygon types.
POINT3D *GEOSGetCoordinates_Polygon(Polygon *g1)
{
try {
int t, r, outidx=0;
const CoordinateList *cl;
Coordinate c;
const LineString *lr;
int npts, nrings;
POINT3D *result;
npts = g1->getNumPoints();
result = (POINT3D*) malloc (sizeof(POINT3D) * npts);
// Exterior ring
lr = g1->getExteriorRing();
cl = lr->getCoordinatesRO();
npts = lr->getNumPoints();
for (t=0; tgetAt(t);
result[outidx].x = c.x;
result[outidx].y = c.y;
result[outidx].z = c.z;
outidx++;
}
// Interior rings
nrings = g1->getNumInteriorRing();
for (r=0; rgetInteriorRingN(r);
cl = lr->getCoordinatesRO();
npts = lr->getNumPoints();
for (t=0; tgetAt(t);
result[outidx].x = c.x;
result[outidx].y = c.y;
result[outidx].z = c.z;
outidx++;
}
}
return result;
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return NULL;
}
catch(...)
{
return NULL;
}
}
int GEOSGetNumCoordinate(Geometry *g1)
{
try{
return g1->getNumPoints();
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return 0;
}
catch(...)
{
return 0;
}
}
int GEOSGetNumInteriorRings(Geometry *g1)
{
try{
Polygon *p = (Polygon *) g1;
return p->getNumInteriorRing();
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return 0;
}
catch(...)
{
return 0;
}
}
//only call on GCs (or multi*)
int GEOSGetNumGeometries(Geometry *g1)
{
try{
GeometryCollection *gc = (GeometryCollection *) g1;
return gc->getNumGeometries();
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return 0;
}
catch(...)
{
return 0;
}
}
//call only on GEOMETRYCOLLECTION or MULTI*
const Geometry *GEOSGetGeometryN(Geometry *g1, int n)
{
try{
const GeometryCollection *gc = (GeometryCollection *) g1;
return gc->getGeometryN(n);
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return NULL;
}
catch(...)
{
return NULL;
}
}
//call only on polygon
const Geometry *GEOSGetExteriorRing(Geometry *g1)
{
try{
Polygon *p = (Polygon *) g1;
return p->getExteriorRing();
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return 0;
}
catch(...)
{
return 0;
}
}
//call only on polygon
const Geometry *GEOSGetInteriorRingN(Geometry *g1,int n)
{
try{
Polygon *p = (Polygon *) g1;
return p->getInteriorRingN(n);
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return NULL;
}
catch(...)
{
return NULL;
}
}
Geometry *GEOSGetCentroid(Geometry *g)
{
try{
return g->getCentroid();
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return NULL;
}
catch(...)
{
return NULL;
}
}
int GEOSGetSRID(Geometry *g1)
{
try{
return g1->getSRID();
}
catch (GEOSException *ge)
{
NOTICE_MESSAGE((char *)ge->toString().c_str());
delete ge;
return 0;
}
catch(...)
{
return 0;
}
}
postgis-0.8.1/postgis_gist_71.c 0100664 0000773 0000144 00000036172 07714764650 016050 0 ustar postgis users
/**********************************************************************
* $Id: postgis_gist_71.c,v 1.3 2025/08/08 18:19:20 dblasby Exp $
*
* PostGIS - Spatial Types for PostgreSQL
* http://postgis.refractions.net
* Copyright 2001-2003 Refractions Research Inc.
*
* This is free software; you can redistribute and/or modify it under
* the terms of hte GNU General Public Licence. See the COPYING file.
*
**********************************************************************
* $Log: postgis_gist_71.c,v $
* Revision 1.3 2025/08/08 18:19:20 dblasby
* Conformance changes.
* Removed junk from postgis_debug.c and added the first run of the long
* transaction locking support. (this will change - dont use it)
* conformance tests were corrected
* some dos cr/lf removed
* empty geometries i.e. GEOMETRYCOLLECT(EMPTY) added (with indexing support)
* pointN(,1) now returns the first point (used to return 2nd)
*
* Revision 1.2 2025/07/01 18:30:55 pramsey
* Added CVS revision headers.
*
*
**********************************************************************/
#include "postgres.h"
#include
#include
#include
#include
#include
#include "access/gist.h"
#include "access/itup.h"
#include "access/rtree.h"
#include "fmgr.h"
#include "postgis.h"
#include "utils/elog.h"
//Norman Vine found this problem for compiling under cygwin
// it defines BYTE_ORDER and LITTLE_ENDIAN
#ifdef __CYGWIN__
#include // FOR ENDIAN DEFINES
#endif
#define SHOW_DIGS_DOUBLE 15
#define MAX_DIGS_DOUBLE (SHOW_DIGS_DOUBLE + 6 + 1 + 3 +1)
// #define DEBUG_GIST
//for GIST index
typedef char* (*BINARY_UNION)(char*, char*, int*);
typedef float (*SIZE_BOX)(char*);
typedef Datum (*RDF)(PG_FUNCTION_ARGS);
GISTENTRY *ggeometry_compress(PG_FUNCTION_ARGS);
GEOMETRYKEY *ggeometry_union(PG_FUNCTION_ARGS);
GIST_SPLITVEC * ggeometry_picksplit(PG_FUNCTION_ARGS);
bool ggeometry_consistent(PG_FUNCTION_ARGS);
float * ggeometry_penalty(PG_FUNCTION_ARGS);
bool * ggeometry_same(PG_FUNCTION_ARGS);
char * ggeometry_binary_union(char *r1, char *r2, int *sizep);
float size_geometrykey( char *pk );
Datum ggeometry_inter(PG_FUNCTION_ARGS);
/*
** Common rtree-function (for all ops)
*/
char * rtree_union(bytea *entryvec, int *sizep, BINARY_UNION bu);
float * rtree_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result, BINARY_UNION bu, SIZE_BOX sb);
GIST_SPLITVEC * rtree_picksplit(bytea *entryvec, GIST_SPLITVEC *v, int keylen, BINARY_UNION bu, RDF interop, SIZE_BOX sb);
bool rtree_internal_consistent(BOX *key, BOX *query, StrategyNumber strategy);
GISTENTRY *rtree_decompress(PG_FUNCTION_ARGS);
//restriction in the GiST && operator
Datum postgis_gist_sel(PG_FUNCTION_ARGS)
{
PG_RETURN_FLOAT8(0.000005);
}
BOX *convert_box3d_to_box(BOX3D *in)
{
BOX *out = palloc (sizeof (BOX) );
out->high.x = in->URT.x;
out->high.y = in->URT.y;
out->low.x = in->LLB.x;
out->low.y = in->LLB.y;
return out;
}
PG_FUNCTION_INFO_V1(ggeometry_compress);
GISTENTRY *ggeometry_compress(PG_FUNCTION_ARGS)
{
GISTENTRY *entry=(GISTENTRY*)PG_GETARG_POINTER(0);
GISTENTRY *retval;
if ( entry->leafkey) {
retval = palloc(sizeof(GISTENTRY));
if ( entry->pred ) {
GEOMETRY *in;
GEOMETRYKEY *r;
BOX *thebox;
#ifdef DEBUG_GIST2
printf("GIST: ggeometry_compress called on geometry\n");
#endif
in = (GEOMETRY*)PG_DETOAST_DATUM(PointerGetDatum(entry->pred));
if (in->nobjs ==0) // this is the EMPTY geometry
{
//elog(NOTICE,"found an empty geometry");
// dont bother adding this to the index
PG_RETURN_POINTER(entry);
}
r = (GEOMETRYKEY*)palloc( sizeof(GEOMETRYKEY) );
r->size = sizeof(GEOMETRYKEY);
r->SRID = in->SRID;
thebox = convert_box3d_to_box(&in->bvol);
memcpy( (void*)&(r->key), (void*)thebox, sizeof(BOX) );
if ( (char*)in != entry->pred )
{
pfree( in );
pfree(thebox);
}
gistentryinit(*retval, (char*)r, entry->rel, entry->page,
entry->offset, sizeof(GEOMETRYKEY),FALSE);
} else {
gistentryinit(*retval, NULL, entry->rel, entry->page,
entry->offset, 0,FALSE);
}
} else {
retval = entry;
}
return( retval );
}
PG_FUNCTION_INFO_V1(ggeometry_consistent);
bool ggeometry_consistent(PG_FUNCTION_ARGS)
{
GISTENTRY *entry = (GISTENTRY*) PG_GETARG_POINTER(0);
GEOMETRY *query = (GEOMETRY*) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
BOX *thebox;
/*
** if entry is not leaf, use gbox_internal_consistent,
** else use gbox_leaf_consistent
*/
#ifdef DEBUG_GIST2
printf("GIST: ggeometry_consistent called\n");
#endif
if ( ! (entry->pred && query) )
return FALSE;
thebox = convert_box3d_to_box( &(query->bvol) );
if( ((GEOMETRYKEY *)(entry->pred))->SRID != query->SRID)
{
elog(ERROR,"Operation on two GEOMETRIES with different SRIDs (ggeometry_consistent)\n");
PG_RETURN_BOOL(FALSE);
}
PG_RETURN_BOOL(rtree_internal_consistent((BOX*)&( ((GEOMETRYKEY *)(entry->pred))->key ),
thebox, strategy));
}
PG_FUNCTION_INFO_V1(ggeometry_union);
GEOMETRYKEY *ggeometry_union(PG_FUNCTION_ARGS)
{
GEOMETRYKEY *result;
#ifdef DEBUG_GIST2
printf("GIST: ggeometry_union called\n");
#endif
result = (GEOMETRYKEY*)
rtree_union(
(bytea*) PG_GETARG_POINTER(0),
(int*) PG_GETARG_POINTER(1),
ggeometry_binary_union
);
return result;
}
PG_FUNCTION_INFO_V1(ggeometry_penalty);
float *ggeometry_penalty(PG_FUNCTION_ARGS)
{
#ifdef DEBUG_GIST2
printf("GIST: ggeometry_penalty called\n");
#endif
return rtree_penalty(
(GISTENTRY*) PG_GETARG_POINTER(0),
(GISTENTRY*) PG_GETARG_POINTER(1),
(float*) PG_GETARG_POINTER(2),
ggeometry_binary_union,
size_geometrykey
);
}
PG_FUNCTION_INFO_V1(ggeometry_picksplit);
GIST_SPLITVEC *ggeometry_picksplit(PG_FUNCTION_ARGS)
{
#ifdef DEBUG_GIST2
printf("GIST: ggeometry_picksplit called\n");
#endif
return rtree_picksplit(
(bytea*)PG_GETARG_POINTER(0),
(GIST_SPLITVEC*)PG_GETARG_POINTER(1),
sizeof(GEOMETRYKEY),
ggeometry_binary_union,
ggeometry_inter,
size_geometrykey
);
}
PG_FUNCTION_INFO_V1(ggeometry_same);
bool *ggeometry_same(PG_FUNCTION_ARGS)
{
GEOMETRYKEY *b1 = (GEOMETRYKEY*) PG_GETARG_POINTER(0);
GEOMETRYKEY *b2 = (GEOMETRYKEY*) PG_GETARG_POINTER(1);
bool *result = (bool*) PG_GETARG_POINTER(2);
#ifdef DEBUG_GIST2
printf("GIST: ggeometry_same called\n");
#endif
if ( b1 && b2 )
*result = DatumGetBool( DirectFunctionCall2( box_same,
PointerGetDatum(&(b1->key)),
PointerGetDatum(&(b2->key))) );
else
*result = ( b1==NULL && b2==NULL ) ? TRUE : FALSE;
return(result);
}
PG_FUNCTION_INFO_V1(ggeometry_inter);
Datum ggeometry_inter(PG_FUNCTION_ARGS) {
GEOMETRYKEY *b1 = (GEOMETRYKEY*) PG_GETARG_POINTER(0);
GEOMETRYKEY*b2 = (GEOMETRYKEY*) PG_GETARG_POINTER(1);
char *interd;
#ifdef DEBUG_GIST2
printf("GIST: ggeometry_inter called\n");
#endif
interd = DatumGetPointer(DirectFunctionCall2(
rt_box_inter,
PointerGetDatum( &(b1->key) ),
PointerGetDatum( &(b2->key) )) );
if (interd) {
GEOMETRYKEY *tmp = (GEOMETRYKEY*)palloc( sizeof(GEOMETRYKEY) );
tmp->size = sizeof(GEOMETRYKEY);
memcpy( (void*)&(tmp->key), (void*)interd, sizeof(BOX) );
tmp->SRID = b1->SRID;
pfree( interd );
PG_RETURN_POINTER( tmp );
} else
PG_RETURN_POINTER( NULL );
}
char *ggeometry_binary_union(char *r1, char *r2, int *sizep)
{
GEOMETRYKEY *retval;
#ifdef DEBUG_GIST2
printf("GIST: ggeometry_binary_union called\n");
#endif
if ( ! (r1 && r2) ) {
if ( r1 ) {
retval = (GEOMETRYKEY*)palloc( sizeof(GEOMETRYKEY) );
memcpy( (void*)retval, (void*)r1, sizeof(GEOMETRYKEY) );
*sizep = sizeof(GEOMETRYKEY);
} else if ( r2 ) {
retval = (GEOMETRYKEY*)palloc( sizeof(GEOMETRYKEY) );
memcpy( (void*)retval, (void*)r2, sizeof(GEOMETRYKEY) );
*sizep = sizeof(GEOMETRYKEY);
} else {
*sizep = 0;
retval = NULL;
}
} else {
BOX *key = (BOX*)DatumGetPointer( DirectFunctionCall2(
rt_box_union,
PointerGetDatum( &(((GEOMETRYKEY*)r1)->key) ),
PointerGetDatum( &(((GEOMETRYKEY*)r2)->key) )) );
retval = (GEOMETRYKEY*)palloc( sizeof(GEOMETRYKEY) );
retval->SRID = ((GEOMETRYKEY *) r1)->SRID;
memcpy( (void*)&(retval->key), (void*)key, sizeof(BOX) );
pfree( key );
*sizep = retval->size = sizeof(GEOMETRYKEY);
}
return (char*)retval;
}
float size_geometrykey( char *pk ) {
#ifdef DEBUG_GIST2
printf("GIST: size_geometrykey called\n");
#endif
if ( pk ) {
float size;
DirectFunctionCall2( rt_box_size,
PointerGetDatum( &(((GEOMETRYKEY*)pk)->key) ),
PointerGetDatum( &size ) );
return size;
} else
return 0.0;
}
char *rtree_union(bytea *entryvec, int *sizep, BINARY_UNION bu)
{
int numranges, i;
char *out, *tmp;
#ifdef DEBUG_GIST2
printf("GIST: rtree_union called\n");
#endif
numranges = (VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY);
tmp = (char *)(((GISTENTRY *)(VARDATA(entryvec)))[0]).pred;
out = NULL;
for (i = 1; i < numranges; i++) {
out = (*bu)(tmp, (char *)
(((GISTENTRY *)(VARDATA(entryvec)))[i]).pred,
sizep);
if (i > 1 && tmp) pfree(tmp);
tmp = out;
}
return(out);
}
float *rtree_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result, BINARY_UNION bu, SIZE_BOX sb)
{
char * ud;
float tmp1;
int sizep;
#ifdef DEBUG_GIST2
printf("GIST: rtree_penalty called\n");
#endif
ud = (*bu)( origentry->pred, newentry->pred, &sizep );
tmp1 = (*sb)( ud );
if (ud) pfree(ud);
*result = tmp1 - (*sb)( origentry->pred );
return(result);
}
/*
** The GiST PickSplit method
** We use Guttman's poly time split algorithm
*/
GIST_SPLITVEC *rtree_picksplit(bytea *entryvec, GIST_SPLITVEC *v, int keylen, BINARY_UNION bu, RDF interop, SIZE_BOX sb)
{
OffsetNumber i, j;
char *datum_alpha, *datum_beta;
char *datum_l, *datum_r;
char *union_d, *union_dl, *union_dr;
char *inter_d;
bool firsttime;
float size_alpha, size_beta, size_union, size_inter;
float size_waste, waste;
float size_l, size_r;
int nbytes;
int sizep;
OffsetNumber seed_1 = 0, seed_2 = 0;
OffsetNumber *left, *right;
OffsetNumber maxoff;
#ifdef DEBUG_GIST2
printf("GIST: rtree_picsplit called\n");
#endif
maxoff = ((VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY)) - 2;
nbytes = (maxoff + 2) * sizeof(OffsetNumber);
v->spl_left = (OffsetNumber *) palloc(nbytes);
v->spl_right = (OffsetNumber *) palloc(nbytes);
firsttime = true;
waste = 0.0;
for (i = FirstOffsetNumber; i < maxoff; i = OffsetNumberNext(i)) {
datum_alpha = (char *)(((GISTENTRY *)(VARDATA(entryvec)))[i].pred);
for (j = OffsetNumberNext(i); j <= maxoff; j = OffsetNumberNext(j)) {
datum_beta = (char *)(((GISTENTRY *)(VARDATA(entryvec)))[j].pred);
/* compute the wasted space by unioning these guys */
/* size_waste = size_union - size_inter; */
union_d = (*bu)( datum_alpha, datum_beta, &sizep );
if ( union_d ) {
size_union = (*sb)(union_d);
pfree(union_d);
} else
size_union = 0.0;
if ( datum_alpha && datum_beta ) {
inter_d = DatumGetPointer(DirectFunctionCall2(
interop,
PointerGetDatum( datum_alpha ),
PointerGetDatum( datum_beta )) );
if ( inter_d ) {
size_inter = (*sb)(inter_d);
pfree(inter_d);
} else
size_inter = 0.0;
} else
size_inter = 0.0;
size_waste = size_union - size_inter;
/*
* are these a more promising split that what we've
* already seen?
*/
if (size_waste > waste || firsttime) {
waste = size_waste;
seed_1 = i;
seed_2 = j;
firsttime = false;
}
}
}
left = v->spl_left;
v->spl_nleft = 0;
right = v->spl_right;
v->spl_nright = 0;
if ( ((GISTENTRY *)(VARDATA(entryvec)))[seed_1].pred ) {
datum_l = (char*) palloc( keylen );
memcpy( (void*)datum_l, (void*)(((GISTENTRY *)(VARDATA(entryvec)))[seed_1].pred ), keylen );
} else
datum_l = NULL;
size_l = (*sb)( datum_l );
if ( ((GISTENTRY *)(VARDATA(entryvec)))[seed_2].pred ) {
datum_r = (char*) palloc( keylen );
memcpy( (void*)datum_r, (void*)(((GISTENTRY *)(VARDATA(entryvec)))[seed_2].pred ), keylen );
} else
datum_r = NULL;
size_r = (*sb)( datum_r );
/*
* Now split up the regions between the two seeds. An important
* property of this split algorithm is that the split vector v
* has the indices of items to be split in order in its left and
* right vectors. We exploit this property by doing a merge in
* the code that actually splits the page.
*
* For efficiency, we also place the new index tuple in this loop.
* This is handled at the very end, when we have placed all the
* existing tuples and i == maxoff + 1.
*/
maxoff = OffsetNumberNext(maxoff);
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) {
/*
* If we've already decided where to place this item, just
* put it on the right list. Otherwise, we need to figure
* out which page needs the least enlargement in order to
* store the item.
*/
if (i == seed_1) {
*left++ = i;
v->spl_nleft++;
continue;
} else if (i == seed_2) {
*right++ = i;
v->spl_nright++;
continue;
}
/* okay, which page needs least enlargement? */
datum_alpha = (char *)(((GISTENTRY *)(VARDATA(entryvec)))[i].pred);
union_dl = (*bu)( datum_l, datum_alpha, &sizep );
union_dr = (*bu)( datum_r, datum_alpha, &sizep );
size_alpha = (*sb)( union_dl );
size_beta = (*sb)( union_dr );
/* pick which page to add it to */
if (size_alpha - size_l < size_beta - size_r) {
pfree(datum_l);
pfree(union_dr);
datum_l = union_dl;
size_l = size_alpha;
*left++ = i;
v->spl_nleft++;
} else {
pfree(datum_r);
pfree(union_dl);
datum_r = union_dr;
size_r = size_alpha;
*right++ = i;
v->spl_nright++;
}
}
*left = *right = FirstOffsetNumber; /* sentinel value, see dosplit() */
v->spl_ldatum = datum_l;
v->spl_rdatum = datum_r;
return( v );
}
bool rtree_internal_consistent(BOX *key,
BOX *query,
StrategyNumber strategy)
{
bool retval;
#ifdef DEBUG_GIST2
printf("GIST: rtree_internal_consist called\n");
#endif
switch(strategy) {
case RTLeftStrategyNumber:
case RTOverLeftStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_overleft, PointerGetDatum(key), PointerGetDatum(query) ) );
break;
case RTOverlapStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_overlap, PointerGetDatum(key), PointerGetDatum(query) ) );
break;
case RTOverRightStrategyNumber:
case RTRightStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_right, PointerGetDatum(key), PointerGetDatum(query) ) );
break;
case RTSameStrategyNumber:
case RTContainsStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_contain, PointerGetDatum(key), PointerGetDatum(query) ) );
break;
case RTContainedByStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_overlap, PointerGetDatum(key), PointerGetDatum(query) ) );
break;
default:
retval = FALSE;
}
return(retval);
}
PG_FUNCTION_INFO_V1(rtree_decompress);
GISTENTRY *rtree_decompress(PG_FUNCTION_ARGS)
{
return((GISTENTRY*)PG_GETARG_POINTER(0));
}
postgis-0.8.1/postgis_gist_72.c 0100664 0000773 0000144 00000035123 07714764650 016044 0 ustar postgis users
/**********************************************************************
* $Id: postgis_gist_72.c,v 1.6 2025/08/08 18:19:20 dblasby Exp $
*
* PostGIS - Spatial Types for PostgreSQL
* http://postgis.refractions.net
* Copyright 2001-2003 Refractions Research Inc.
*
* This is free software; you can redistribute and/or modify it under
* the terms of hte GNU General Public Licence. See the COPYING file.
*
**********************************************************************
* $Log: postgis_gist_72.c,v $
* Revision 1.6 2025/08/08 18:19:20 dblasby
* Conformance changes.
* Removed junk from postgis_debug.c and added the first run of the long
* transaction locking support. (this will change - dont use it)
* conformance tests were corrected
* some dos cr/lf removed
* empty geometries i.e. GEOMETRYCOLLECT(EMPTY) added (with indexing support)
* pointN(,1) now returns the first point (used to return 2nd)
*
* Revision 1.5 2025/07/01 18:30:55 pramsey
* Added CVS revision headers.
*
*
**********************************************************************
*
* GiST indexing functions for pgsql >= 7.2
*
**********************************************************************/
#include "postgres.h"
#include
#include
#include
#include
#include
#include "access/gist.h"
#include "access/itup.h"
#include "access/rtree.h"
#include "fmgr.h"
#include "postgis.h"
#include "utils/elog.h"
//Norman Vine found this problem for compiling under cygwin
// it defines BYTE_ORDER and LITTLE_ENDIAN
#ifdef __CYGWIN__
#include // FOR ENDIAN DEFINES
#endif
#define SHOW_DIGS_DOUBLE 15
#define MAX_DIGS_DOUBLE (SHOW_DIGS_DOUBLE + 6 + 1 + 3 +1)
//#define DEBUG_GIST
//for GIST index
typedef char* (*BINARY_UNION)(char*, char*, int*);
typedef float (*SIZE_BOX)(char*);
typedef Datum (*RDF)(PG_FUNCTION_ARGS);
BOX *convert_box3d_to_box(BOX3D *in);
Datum ggeometry_compress(PG_FUNCTION_ARGS);
Datum ggeometry_consistent(PG_FUNCTION_ARGS);
bool rtree_internal_consistent(BOX *key, BOX *query,StrategyNumber strategy);
Datum rtree_decompress(PG_FUNCTION_ARGS);
Datum gbox_union(PG_FUNCTION_ARGS);
Datum gbox_picksplit(PG_FUNCTION_ARGS);
Datum gbox_penalty(PG_FUNCTION_ARGS);
Datum gbox_same(PG_FUNCTION_ARGS);
static float size_box(Datum box);
int debug = 0;
BOX *convert_box3d_to_box(BOX3D *in)
{
BOX *out = palloc (sizeof (BOX) );
out->high.x = in->URT.x;
out->high.y = in->URT.y;
out->low.x = in->LLB.x;
out->low.y = in->LLB.y;
return out;
}
PG_FUNCTION_INFO_V1(ggeometry_compress);
Datum ggeometry_compress(PG_FUNCTION_ARGS)
{
GISTENTRY *entry=(GISTENTRY*)PG_GETARG_POINTER(0);
GISTENTRY *retval;
if ( entry->leafkey)
{
retval = palloc(sizeof(GISTENTRY));
if ( DatumGetPointer(entry->key) != NULL )
{
GEOMETRY *in;
BOX *r;
#ifdef DEBUG_GIST
elog(NOTICE,"GIST: ggeometry_compress called on geometry\n");
fflush( stdout );
#endif
in = (GEOMETRY*)PG_DETOAST_DATUM( entry->key );
if (in->nobjs ==0) // this is the EMPTY geometry
{
//elog(NOTICE,"found an empty geometry");
// dont bother adding this to the index
PG_RETURN_POINTER(entry);
}
else
{
r = convert_box3d_to_box(&in->bvol);
if ( in != (GEOMETRY*)DatumGetPointer(entry->key) )
{
pfree( in );
}
gistentryinit(*retval, PointerGetDatum(r), entry->rel, entry->page,
entry->offset, sizeof(BOX), FALSE);
}
}
else
{
gistentryinit(*retval, (Datum) 0, entry->rel, entry->page,
entry->offset, 0,FALSE);
}
}
else
{
retval = entry;
}
PG_RETURN_POINTER(retval);
}
PG_FUNCTION_INFO_V1(ggeometry_consistent);
Datum ggeometry_consistent(PG_FUNCTION_ARGS)
{
GISTENTRY *entry = (GISTENTRY*) PG_GETARG_POINTER(0);
GEOMETRY *query = (GEOMETRY*) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
BOX *thebox;
bool result;
/*
** if entry is not leaf, use gbox_internal_consistent,
** else use gbox_leaf_consistent
*/
#ifdef DEBUG_GIST
elog(NOTICE,"GIST: ggeometry_consistent called\n");
fflush( stdout );
#endif
if ( ! (DatumGetPointer(entry->key) != NULL && query) )
PG_RETURN_BOOL(FALSE);
thebox = convert_box3d_to_box( &(query->bvol) );
result = rtree_internal_consistent((BOX *) DatumGetPointer(entry->key), thebox, strategy );
PG_FREE_IF_COPY(query, 1);
PG_RETURN_BOOL(result);
}
bool rtree_internal_consistent(BOX *key,
BOX *query,
StrategyNumber strategy)
{
bool retval;
#ifdef DEBUG_GIST
elog(NOTICE,"GIST: rtree_internal_consist called\n");
fflush( stdout );
#endif
switch(strategy) {
case RTLeftStrategyNumber:
case RTOverLeftStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_overleft, PointerGetDatum(key), PointerGetDatum(query) ) );
break;
case RTOverlapStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_overlap, PointerGetDatum(key), PointerGetDatum(query) ) );
break;
case RTOverRightStrategyNumber:
case RTRightStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_right, PointerGetDatum(key), PointerGetDatum(query) ) );
break;
case RTSameStrategyNumber:
case RTContainsStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_contain, PointerGetDatum(key), PointerGetDatum(query) ) );
break;
case RTContainedByStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_overlap, PointerGetDatum(key), PointerGetDatum(query) ) );
break;
default:
retval = FALSE;
}
return(retval);
}
PG_FUNCTION_INFO_V1(rtree_decompress);
Datum rtree_decompress(PG_FUNCTION_ARGS)
{
PG_RETURN_POINTER(PG_GETARG_POINTER(0));
}
/*
** The GiST Union method for boxes
** returns the minimal bounding box that encloses all the entries in entryvec
*/
PG_FUNCTION_INFO_V1(gbox_union);
Datum gbox_union(PG_FUNCTION_ARGS)
{
bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
int *sizep = (int *) PG_GETARG_POINTER(1);
int numranges,
i;
BOX *cur,
*pageunion;
#ifdef DEBUG_GIST
elog(NOTICE,"GIST: gbox_union called\n");
fflush( stdout );
#endif
numranges = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
pageunion = (BOX *) palloc(sizeof(BOX));
cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[0].key);
memcpy((void *) pageunion, (void *) cur, sizeof(BOX));
for (i = 1; i < numranges; i++)
{
cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[i].key);
if (pageunion->high.x < cur->high.x)
pageunion->high.x = cur->high.x;
if (pageunion->low.x > cur->low.x)
pageunion->low.x = cur->low.x;
if (pageunion->high.y < cur->high.y)
pageunion->high.y = cur->high.y;
if (pageunion->low.y > cur->low.y)
pageunion->low.y = cur->low.y;
}
*sizep = sizeof(BOX);
PG_RETURN_POINTER(pageunion);
}
/*
** The GiST Penalty method for boxes
** As in the R-tree paper, we use change in area as our penalty metric
*/
PG_FUNCTION_INFO_V1(gbox_penalty);
Datum gbox_penalty(PG_FUNCTION_ARGS)
{
GISTENTRY *origentry = (GISTENTRY *) PG_GETARG_POINTER(0);
GISTENTRY *newentry = (GISTENTRY *) PG_GETARG_POINTER(1);
float *result = (float *) PG_GETARG_POINTER(2);
Datum ud;
float tmp1;
#ifdef DEBUG_GIST
elog(NOTICE,"GIST: gbox_penalty called\n");
fflush( stdout );
#endif
ud = DirectFunctionCall2(rt_box_union, origentry->key, newentry->key);
tmp1 = size_box(ud);
if (DatumGetPointer(ud) != NULL)
pfree(DatumGetPointer(ud));
*result = tmp1 - size_box(origentry->key);
PG_RETURN_POINTER(result);
}
typedef struct {
BOX *key;
int pos;
} KBsort;
static int
compare_KB(const void* a, const void* b) {
BOX *abox = ((KBsort*)a)->key;
BOX *bbox = ((KBsort*)b)->key;
float sa = (abox->high.x - abox->low.x) * (abox->high.y - abox->low.y);
float sb = (bbox->high.x - bbox->low.x) * (bbox->high.y - bbox->low.y);
if ( sa==sb ) return 0;
return ( sa>sb ) ? 1 : -1;
}
/*
** The GiST PickSplit method
** New linear algorithm, see 'New Linear Node Splitting Algorithm for R-tree',
** C.H.Ang and T.C.Tan
*/
PG_FUNCTION_INFO_V1(gbox_picksplit);
Datum
gbox_picksplit(PG_FUNCTION_ARGS)
{
bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
OffsetNumber i;
OffsetNumber *listL,
*listR,
*listB,
*listT;
BOX *unionL,
*unionR,
*unionB,
*unionT;
int posL,
posR,
posB,
posT;
BOX pageunion;
BOX *cur;
char direction = ' ';
bool allisequal = true;
OffsetNumber maxoff;
int nbytes;
#ifdef DEBUG_GIST
elog(NOTICE,"GIST: gbox_picksplit called\n");
fflush( stdout );
#endif
posL = posR = posB = posT = 0;
maxoff = ((VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY)) - 1;
cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[FirstOffsetNumber].key);
memcpy((void *) &pageunion, (void *) cur, sizeof(BOX));
/* find MBR */
for (i = OffsetNumberNext(FirstOffsetNumber); i <= maxoff; i = OffsetNumberNext(i))
{
cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[i].key);
if ( allisequal == true && (
pageunion.high.x != cur->high.x ||
pageunion.high.y != cur->high.y ||
pageunion.low.x != cur->low.x ||
pageunion.low.y != cur->low.y
) )
allisequal = false;
if (pageunion.high.x < cur->high.x)
pageunion.high.x = cur->high.x;
if (pageunion.low.x > cur->low.x)
pageunion.low.x = cur->low.x;
if (pageunion.high.y < cur->high.y)
pageunion.high.y = cur->high.y;
if (pageunion.low.y > cur->low.y)
pageunion.low.y = cur->low.y;
}
nbytes = (maxoff + 2) * sizeof(OffsetNumber);
listL = (OffsetNumber *) palloc(nbytes);
listR = (OffsetNumber *) palloc(nbytes);
unionL = (BOX *) palloc(sizeof(BOX));
unionR = (BOX *) palloc(sizeof(BOX));
if (allisequal)
{
cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[OffsetNumberNext(FirstOffsetNumber)].key);
if (memcmp((void *) cur, (void *) &pageunion, sizeof(BOX)) == 0)
{
v->spl_left = listL;
v->spl_right = listR;
v->spl_nleft = v->spl_nright = 0;
memcpy((void *) unionL, (void *) &pageunion, sizeof(BOX));
memcpy((void *) unionR, (void *) &pageunion, sizeof(BOX));
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
{
if (i <= (maxoff - FirstOffsetNumber + 1) / 2)
{
v->spl_left[v->spl_nleft] = i;
v->spl_nleft++;
}
else
{
v->spl_right[v->spl_nright] = i;
v->spl_nright++;
}
}
v->spl_ldatum = BoxPGetDatum(unionL);
v->spl_rdatum = BoxPGetDatum(unionR);
PG_RETURN_POINTER(v);
}
}
listB = (OffsetNumber *) palloc(nbytes);
listT = (OffsetNumber *) palloc(nbytes);
unionB = (BOX *) palloc(sizeof(BOX));
unionT = (BOX *) palloc(sizeof(BOX));
#define ADDLIST( list, unionD, pos, num ) do { \
if ( pos ) { \
if ( unionD->high.x < cur->high.x ) unionD->high.x = cur->high.x; \
if ( unionD->low.x > cur->low.x ) unionD->low.x = cur->low.x; \
if ( unionD->high.y < cur->high.y ) unionD->high.y = cur->high.y; \
if ( unionD->low.y > cur->low.y ) unionD->low.y = cur->low.y; \
} else { \
memcpy( (void*)unionD, (void*) cur, sizeof( BOX ) ); \
} \
list[pos] = num; \
(pos)++; \
} while(0)
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
{
cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[i].key);
if (cur->low.x - pageunion.low.x < pageunion.high.x - cur->high.x)
ADDLIST(listL, unionL, posL,i);
else
ADDLIST(listR, unionR, posR,i);
if (cur->low.y - pageunion.low.y < pageunion.high.y - cur->high.y)
ADDLIST(listB, unionB, posB,i);
else
ADDLIST(listT, unionT, posT,i);
}
/* bad disposition, sort by ascending and resplit */
if ( (posR==0 || posL==0) && (posT==0 || posB==0) ) {
KBsort *arr = (KBsort*)palloc( sizeof(KBsort) * maxoff );
posL = posR = posB = posT = 0;
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) {
arr[i-1].key = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[i].key);
arr[i-1].pos = i;
}
qsort( arr, maxoff, sizeof(KBsort), compare_KB );
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) {
cur = arr[i-1].key;
if (cur->low.x - pageunion.low.x < pageunion.high.x - cur->high.x)
ADDLIST(listL, unionL, posL,arr[i-1].pos);
else if ( cur->low.x - pageunion.low.x == pageunion.high.x - cur->high.x ) {
if ( posL>posR )
ADDLIST(listR, unionR, posR,arr[i-1].pos);
else
ADDLIST(listL, unionL, posL,arr[i-1].pos);
} else
ADDLIST(listR, unionR, posR,arr[i-1].pos);
if (cur->low.y - pageunion.low.y < pageunion.high.y - cur->high.y)
ADDLIST(listB, unionB, posB,arr[i-1].pos);
else if ( cur->low.y - pageunion.low.y == pageunion.high.y - cur->high.y ) {
if ( posB>posT )
ADDLIST(listT, unionT, posT,arr[i-1].pos);
else
ADDLIST(listB, unionB, posB,arr[i-1].pos);
} else
ADDLIST(listT, unionT, posT,arr[i-1].pos);
}
pfree(arr);
}
/* which split more optimal? */
if (Max(posL, posR) < Max(posB, posT))
direction = 'x';
else if (Max(posL, posR) > Max(posB, posT))
direction = 'y';
else
{
Datum interLR = DirectFunctionCall2(rt_box_inter,
BoxPGetDatum(unionL),
BoxPGetDatum(unionR));
Datum interBT = DirectFunctionCall2(rt_box_inter,
BoxPGetDatum(unionB),
BoxPGetDatum(unionT));
float sizeLR,
sizeBT;
sizeLR = size_box(interLR);
sizeBT = size_box(interBT);
if (sizeLR < sizeBT)
direction = 'x';
else
direction = 'y';
}
if (direction == 'x')
{
pfree(unionB);
pfree(listB);
pfree(unionT);
pfree(listT);
v->spl_left = listL;
v->spl_right = listR;
v->spl_nleft = posL;
v->spl_nright = posR;
v->spl_ldatum = BoxPGetDatum(unionL);
v->spl_rdatum = BoxPGetDatum(unionR);
}
else
{
pfree(unionR);
pfree(listR);
pfree(unionL);
pfree(listL);
v->spl_left = listB;
v->spl_right = listT;
v->spl_nleft = posB;
v->spl_nright = posT;
v->spl_ldatum = BoxPGetDatum(unionB);
v->spl_rdatum = BoxPGetDatum(unionT);
}
PG_RETURN_POINTER(v);
}
/*
** Equality method
*/
PG_FUNCTION_INFO_V1(gbox_same);
Datum gbox_same(PG_FUNCTION_ARGS)
{
BOX *b1 = (BOX *) PG_GETARG_POINTER(0);
BOX *b2 = (BOX *) PG_GETARG_POINTER(1);
bool *result = (bool *) PG_GETARG_POINTER(2);
#ifdef DEBUG_GIST
elog(NOTICE,"GIST: gbox_same called\n");
fflush( stdout );
#endif
if (b1 && b2)
*result = DatumGetBool(DirectFunctionCall2(box_same, PointerGetDatum(b1), PointerGetDatum(b2)));
else
*result = (b1 == NULL && b2 == NULL) ? TRUE : FALSE;
PG_RETURN_POINTER(result);
}
static float
size_box(Datum box)
{
#ifdef DEBUG_GIST
elog(NOTICE,"GIST: size_box called\n");
fflush( stdout );
#endif
if (DatumGetPointer(box) != NULL)
{
float size;
DirectFunctionCall2(rt_box_size,
box, PointerGetDatum(&size));
return size;
}
else
return 0.0;
}
postgis-0.8.1/postgis_inout.c 0100664 0000773 0000144 00000331164 07766401057 015724 0 ustar postgis users
/**********************************************************************
* $Id: postgis_inout.c,v 1.35 2025/12/12 18:00:15 strk Exp $
*
* PostGIS - Spatial Types for PostgreSQL
* http://postgis.refractions.net
* Copyright 2001-2003 Refractions Research Inc.
*
* This is free software; you can redistribute and/or modify it under
* the terms of hte GNU General Public Licence. See the COPYING file.
*
**********************************************************************
* $Log: postgis_inout.c,v $
* Revision 1.35 2025/12/12 18:00:15 strk
* reverted make_line patch, patched size_subobject instead - the reported bug was caused to their inconsistency
*
* Revision 1.34 2025/12/12 14:39:04 strk
* Fixed a bug in make_line allocating less memory then required
*
* Revision 1.33 2025/12/12 12:03:30 strk
* More debugging output, some code cleanup.
*
* Revision 1.32 2025/12/09 11:58:42 strk
* Final touch to wkb binary input function
*
* Revision 1.31 2025/12/09 11:13:41 strk
* WKB_recv: set StringInfo cursor to the end of StringInfo buf as required by postgres backend
*
* Revision 1.30 2025/12/08 17:57:36 strk
* Binary WKB input function built only when USE_VERSION > 73. Making some modifications based on reported failures
*
* Revision 1.29 2025/11/28 11:06:49 strk
* Added WKB_recv function for binary WKB input
*
* Revision 1.28 2025/10/06 18:09:08 dblasby
* Fixed typo in add_to_geometry(). With very poorly aligned sub-objects, it
* wouldnt allocate enough memory. Fixed it so its pesimistic and will allocate
* enough memory.
*
* Revision 1.27 2025/08/22 17:40:11 dblasby
* fixed geometry_in('SRID={no ;}').
*
* Revision 1.26 2025/08/21 16:22:09 dblasby
* added patch from strk@freek.keybit.net for PG_NARGS() not being in 7.2
*
* Revision 1.25 2025/08/08 18:19:20 dblasby
* Conformance changes.
* Removed junk from postgis_debug.c and added the first run of the long
* transaction locking support. (this will change - dont use it)
* conformance tests were corrected
* some dos cr/lf removed
* empty geometries i.e. GEOMETRYCOLLECT(EMPTY) added (with indexing support)
* pointN(,1) now returns the first point (used to return 2nd)
*
* Revision 1.24 2025/08/06 19:31:18 dblasby
* Added the WKB parser. Added all the functions like
* PolyFromWKB(,[]).
*
* Added all the functions like PolyFromText(,[])
*
* Minor problem in GEOS library fixed.
*
* Revision 1.23 2025/07/25 17:08:37 pramsey
* Moved Cygwin endian define out of source files into postgis.h common
* header file.
*
* Revision 1.22 2025/07/08 18:35:54 dblasby
* changed asbinary_specify() so that it is more aware of TEXT being
* un-terminated.
*
* this is a modified patch from David Garnier .
*
* Revision 1.21 2025/07/01 18:30:55 pramsey
* Added CVS revision headers.
*
*
**********************************************************************/
#include "postgres.h"
#include
#include
#include
#include
#include
#include "access/gist.h"
#include "access/itup.h"
#include "access/rtree.h"
#include "fmgr.h"
#include "postgis.h"
#if USE_VERSION > 73
# include "lib/stringinfo.h" // for WKB binary input
#endif
#include "utils/elog.h"
#define SHOW_DIGS_DOUBLE 15
#define MAX_DIGS_DOUBLE (SHOW_DIGS_DOUBLE + 6 + 1 + 3 +1)
// #define DEBUG_GIST
//#define DEBUG_GIST2
#define WKB3DOFFSET 0x80000000
void swap_char(char *a,char *b)
{
char c;
c = *a;
*a=*b;
*b=c;
}
void flip_endian_double(char *d)
{
swap_char(d+7, d);
swap_char(d+6, d+1);
swap_char(d+5, d+2);
swap_char(d+4, d+3);
}
void flip_endian_int32(char *i)
{
swap_char (i+3,i);
swap_char (i+2,i+1);
}
//takes a point and sticks it at the end of a string
void print_point(char *result, POINT3D *pt,bool is3d)
{
char temp[MAX_DIGS_DOUBLE*3 +6];
if ( (pt == NULL) || (result == NULL) )
return;
if (is3d)
sprintf(temp, "%.15g %.15g %.15g", pt->x,pt->y,pt->z);
else
sprintf(temp, "%.15g %.15g", pt->x,pt->y);
strcat(result,temp);
}
//result MUST BE null terminated (or result[0] = 0)
void print_many_points(char *result, POINT3D *pt ,int npoints, bool is3d)
{
int u;
result += strlen(result);
if (is3d)
{
for (u=0;u 2 (2nd list is not included)
int numb_points_in_list(char *str)
{
bool keep_going;
int points_found = 1; //no "," if only one point (and last point)
// # points = 1 + numb of ","
if ( (str == NULL) || (str[0] == 0) )
{
return 0; //either null string or empty string
}
//look ahead for the "("
str = strchr(str,'(') ;
if ( (str == NULL) || (str[1] == 0) ) // str[0] = '(';
{
return 0; //either didnt find "(" or its at the end of the string
}
keep_going = TRUE;
while (keep_going)
{
str=strpbrk(str,",)"); // look for a "," or ")"
keep_going = (str != NULL);
if (keep_going) // found a , or )
{
if (str[0] == ')')
{
//finished
return points_found;
}
else //str[0] = ","
{
points_found++;
str++; //move 1 char forward
}
}
}
return points_found; // technically it should return an error.
}
//Actually parse the points in a list
// "(1 2 3, 4 5 6),(7 8, 9 10, 11 12 13)" =>
// points[0] = {1,2,3} and points[1] = {4,5,6}
// (2nd list is not parsed)
//
// parse at most max_points (points should already have enough space)
// if any of the points are 3d, is3d is set to true, otherwise its untouched.
// 2d points have z=0.0
//
// returns true if everything parses okay, otherwise false
bool parse_points_in_list(char *str, POINT3D *points, int32 max_points, bool *is3d)
{
bool keep_going;
int numb_found= 0;
int num_entities;
if ( (str == NULL) || (str[0] == 0) || (max_points <0) || (points == NULL) )
{
return FALSE; //either null string or empty string or other problem
}
if (max_points == 0)
return TRUE; //ask for nothing, get nothing
//look ahead for the "("
str = strchr(str,'(') ;
if ( (str == NULL) || (str[1] == 0) ) // str[0] = '(';
{
return FALSE; //either didnt find "(" or its at the end of the string
}
str++; //move forward one char
keep_going = TRUE;
while (keep_going)
{
//attempt to get the point
num_entities = sscanf(str,"%le %le %le", &(points[numb_found].x),
&(points[numb_found].y),
&(points[numb_found].z));
if (num_entities !=3)
{
if (num_entities !=2 )
{
elog(ERROR, "geom3d: parse_points_in_list() on invalid point");
return FALSE; //error
}
else
{
points[numb_found].z = 0.0; //2d (only found x,y - set z =0.0)
}
}
else
{
*is3d = TRUE; //found 3 entites (x,y,z)
}
numb_found++;
str=strpbrk(str,",)"); // look for a "," or ")"
if (str != NULL)
str++;
keep_going = ( (str != NULL) && (str[0] != ')' ) && (numb_found < max_points) );
}
return TRUE;
}
//Actually parse the points in a list
// "(1 2 3, 4 5 6),(7 8, 9 10, 11 12 13)" =>
// points[0] = {1,2,3} and points[1] = {4,5,6}
// (2nd list is not parsed)
//
// parse at most max_points (points should already have enough space)
// if any of the points are 3d, is3d is set to true, otherwise its untouched.
// 2d points have z=0.0
//
// returns true if everything parses okay, otherwise false
//
// THIS IS EXACTLY the same as parse_points_in_list(), but returns FALSE if
// the number of points parsed is != max_points
bool parse_points_in_list_exact(char *str, POINT3D *points, int32 max_points, bool *is3d)
{
bool keep_going;
int numb_found= 0;
char *end_of_double;
if ( (str == NULL) || (str[0] == 0) || (max_points <0) || (points == NULL) )
{
return FALSE; //either null string or empty string or other problem
}
if (max_points == 0)
return TRUE; //ask for nothing, get nothing
//look ahead for the "("
str = strchr(str,'(') ;
if ( (str == NULL) || (str[1] == 0) ) // str[0] = '(';
{
return FALSE; //either didnt find "(" or its at the end of the string
}
str++; //move forward one char
keep_going = TRUE;
while (keep_going)
{
//attempt to get the point
//scanf is slow, so we use strtod()
points[numb_found].x = strtod(str,&end_of_double);
if (end_of_double == str)
{
return FALSE; //error occured (nothing parsed)
}
str = end_of_double;
points[numb_found].y = strtod(str,&end_of_double);
if (end_of_double == str)
{
return FALSE; //error occured (nothing parsed)
}
str = end_of_double;
points[numb_found].z = strtod(str,&end_of_double); //will be zero if error occured
if (!(end_of_double == str))
{
*is3d = TRUE; //found 3 entites (x,y,z)
}
str = end_of_double;
numb_found++;
str=strpbrk(str,",)"); // look for a "," or ")"
if (str != NULL)
str++;
keep_going = ( (str != NULL) && (str[0] != ')' ) && (numb_found < max_points) );
}
return (numb_found == max_points);
}
// Find the number of sub lists in a list
// ( (..),(..),(..) ) -> 3
// ( ( (..),(..) ), ( (..) )) -> 2
// ( ) -> 0
// scan through the list, for every "(", depth (nesting) increases by 1
// for every ")", depth (nesting) decreases by 1
// if find a "(" at depth 1, then there is a sub list
//
// example:
// "(((..),(..)),((..)))"
//depth 12333223332112333210
// + + increase here
int find_outer_list_length(char *str)
{
int current_depth = 0;
int numb_lists = 0;
while ( (str != NULL) && (str[0] != 0) )
{
str=strpbrk(str,"()"); //look for "(" or ")"
if (str != NULL)
{
if (str[0] == '(')
{
current_depth++;
if (current_depth == 2)
numb_lists ++;
}
if (str[0] == ')')
{
current_depth--;
if (current_depth == 0)
return numb_lists ;
}
str++;
}
}
return numb_lists ; // probably should give an error
}
// Find out how many points are in each sublist, put the result in the array npoints[]
// (for at most max_list sublists)
//
// ( (L1),(L2),(L3) ) --> npoints[0] = points in L1,
// npoints[1] = points in L2,
// npoints[2] = points in L3
//
// We find these by, again, scanning through str looking for "(" and ")"
// to determine the current depth. We dont actually parse the points.
bool points_per_sublist( char *str, int32 *npoints, int32 max_lists)
{
//scan through, noting depth and ","s
int current_depth = 0;
int current_list =-1 ;
while ( (str != NULL) && (str[0] != 0) )
{
str=strpbrk(str,"(),"); //find "(" or ")" or ","
if (str != NULL)
{
if (str[0] == '(')
{
current_depth++;
if (current_depth == 2)
{
current_list ++;
if (current_list >=max_lists)
return TRUE; // too many sub lists found
npoints[current_list] = 1;
}
// might want to return an error if depth>2
}
if (str[0] == ')')
{
current_depth--;
if (current_depth == 0)
return TRUE ;
}
if (str[0] == ',')
{
if (current_depth==2)
{
npoints[current_list] ++;
}
}
str++;
}
}
return TRUE ; // probably should give an error
}
//simple scan-forward to find the next "(" at the same level
// ( (), (),(), ),(...
// + return this location
char *scan_to_same_level(char *str)
{
//scan forward in string looking for at "(" at the same level
// as the one its already pointing at
int current_depth = 0;
bool first_one=TRUE;
while ( (str != NULL) && (str[0] != 0) )
{
str=strpbrk(str,"()");
if (str != NULL)
{
if (str[0] == '(')
{
if (!(first_one))
{
if (current_depth == 0)
return str;
}
else
first_one = FALSE; //ignore the first opening "("
current_depth++;
}
if (str[0] == ')')
{
current_depth--;
}
str++;
}
}
return str ; // probably should give an error
}
/*
* BOX3D_in - takes a string rep of BOX3D and returns internal rep
*
* example:
* "BOX3D(x1 y1 z1,x2 y2 z2)"
* or "BOX3D(x1 y1,x2 y2)" z1 and z2 = 0.0
*
*
*/
BOX3D *parse_box3d(char *str)
{
BOX3D *bbox = (BOX3D *) palloc(sizeof(BOX3D));
bool junk_bool;
bool okay;
int npoints;
//verify that there are exactly two points
//strip leading spaces
while (isspace((unsigned char) *str))
str++;
//printf( "box3d_in gets '%s'\n",str);
if (strstr(str,"BOX3D") != str )
{
elog(ERROR,"BOX3D parser - doesnt start with BOX3D");
pfree(bbox);
return NULL;
}
if ((npoints = numb_points_in_list(str)) != 2)
{
//printf("npoints in this bbox is %i, should be 2\n",npoints);
elog(ERROR,"BOX3D parser - number of points should be exactly 2");
pfree(bbox);
return NULL;
}
//want to parse two points, and dont care if they are 2d or 3d
okay = parse_points_in_list(str, &(bbox->LLB), 2, &junk_bool);
if (okay == 0)
{
elog(ERROR,"box3d: couldnt parse: '%s'\n",str);
pfree(bbox);
return NULL;
}
//validate corners so LLB is mins of x,y,z and URT is maxs x,y,z
if ( bbox->LLB.x > bbox->URT.x)
{
swap ( &bbox->LLB.x , &bbox->URT.x ) ;
}
if ( bbox->LLB.y > bbox->URT.y)
{
swap ( &bbox->LLB.y , &bbox->URT.y );
}
if ( bbox->LLB.z > bbox->URT.z)
{
swap ( &bbox->LLB.z , &bbox->URT.z ) ;
}
return bbox;
}
PG_FUNCTION_INFO_V1(box3d_in);
Datum box3d_in(PG_FUNCTION_ARGS)
{
char *str = PG_GETARG_CSTRING(0);
BOX3D *bbox ;
bbox = parse_box3d(str);
if (bbox != NULL)
PG_RETURN_POINTER(bbox);
else
PG_RETURN_NULL();
}
/*
* Takes an internal rep of a BOX3D and returns a string rep.
*
* example:
* "BOX3D(LLB.x LLB.y LLB.z, URT.x URT.y URT.z)"
*/
PG_FUNCTION_INFO_V1(box3d_out);
Datum box3d_out(PG_FUNCTION_ARGS)
{
BOX3D *bbox = (BOX3D *) PG_GETARG_POINTER(0);
int size;
char *result;
if (bbox == NULL)
{
result = palloc(5);
strcat(result,"NULL");
PG_RETURN_CSTRING(result);
}
size = MAX_DIGS_DOUBLE*6+5+2+4+5+1;
result = (char *) palloc(size); //double digits+ "BOX3D"+ "()" + commas +null
sprintf(result, "BOX3D(%.15g %.15g %.15g,%.15g %.15g %.15g)",
bbox->LLB.x,bbox->LLB.y,bbox->LLB.z,
bbox->URT.x,bbox->URT.y,bbox->URT.z);
PG_RETURN_CSTRING(result);
}
/***************************************************************
* these functions return the number of sub-objects inside a
* sub-portion of a string.
*
* LINESTRING(), POLYGON(), POINT() allways have 1 sub object
*
* MULTIPOLYGON() MULTILINESTRING() MULTIPOINT() will have a variable number of sub-parts
* ex MULTIPOINT(1 1 1, 2 2 2,3 3 3,4 4 4) -->4 because there are 4 points in it
*
* GEOMETRYCOLLECTION() - need to look at each sub-object in the collection
***************************************************************/
//number of object inside a point
int objects_inside_point(char *str)
{
return 1; //trivial points always have 1 point in them
}
//number of object inside a line
int objects_inside_line(char *str)
{
return 1; //trivial lines always have 1 line in them
}
//number of object inside a polygon
int objects_inside_polygon(char *str)
{
return 1; //trivial polygon always have 1 polygon in them
}
//bit more complicated - need to find out how many points are in this entity
int objects_inside_multipoint(char *str)
{
return numb_points_in_list(str);
}
//bit more complicated - need to find out how many lines are in this entity
int objects_inside_multiline(char *str)
{
return find_outer_list_length(str);
}
//bit more complicated - need to find out how many polygons are in this entity
int objects_inside_multipolygon(char *str)
{
return find_outer_list_length(str);
}
//This one is more complicated, we have to look at each of the sub-object inside
// the collection.
// result = sum of ( number of objects in each of the collection's sub-objects )
//
// EX: 'GEOMETRYCOLLECTION( POINT(1 2 3),
// POINT (4 5 6) ),
// LINESTRING(3 4 5,1 2 3,5 6 0),
// MULTILINESTRING((3 4 5,1 2 3,5 6 0)),
// MULTIPOINT(1 2 3),
// MULTILINESTRING((3 4 5,1 2 3,5 6 0),(1 2 0,4 5 0,6 7 0,99 99 0)),
// MULTIPOLYGON (( (3 4 5,1 2 3,5 6),(1 2, 4 5, 6 7) ), ( (11 11, 22 22, 33 33),(44 44, 55 55, 66 66) ) )'
//
// # object = # of objs in POINT (1) + # of objs in POINT (1) + # of objs in LINESTRING (1)
// + # of objs in MULTILINESTRING (1) + # of objs in MULTIPOINT (1)
// + # of objs in MULTILINESTRING (1) + # of objs in MULTIPOLYGON (2)
int objects_inside_collection(char *str)
{
int tally = 0;
int sub_size = 0;
//skip past the "geometrycollection" at begining of string
str += 18;
if (strstr(str, "GEOMETRYCOLLECTION") != NULL)
return -1; // collection inside collection; bad boy!
//we scan to the first letter, then pass it to objects inside
// to find out how many sub-objects there are. Then move to
// the next object
while ( str != NULL)
{
//scan for a letter (all objs start with M, P, or L
str = strpbrk(str,"MPL"); //search for MULTI*, POLY*, POIN*
if (str != NULL)
{
//object found
sub_size = objects_inside(str); //how many in this object
if (sub_size == -1)
return -1;//relay error
tally += sub_size; // running total
//need to move to next item
// by scanning past any letters
str = strchr(str,'('); //need to move to the next sub-object
}
}
return tally;
}
// Find the # of sub-objects inside the geometry
// Just pass it off to the other functions
int objects_inside(char *str)
{
char *parenth;
char *loc;
parenth = strchr(str,'(');
if (parenth == NULL)
return -1; //invalid string
// look only at the begining of the string
// the order of these "if" are important!
if ( ((loc = strstr(str, "GEOMETRYCOLLECTION")) != NULL) && (loc < parenth) )
return objects_inside_collection(str);
// do multi before base types (MULTIPOINT has the string "POINT" in it)
if (((loc = strstr(str,"MULTIPOINT")) != NULL) && (loc < parenth) )
return objects_inside_multipoint(str);
if (((loc = strstr(str,"MULTILINESTRING") )!= NULL) && (loc < parenth) )
return objects_inside_multiline(str);
if (((loc = strstr(str,"MULTIPOLYGON")) != NULL) && (loc < parenth) )
return objects_inside_multipolygon(str);
//base types
if (((loc = strstr(str,"POINT")) != NULL) && (loc < parenth) )
return objects_inside_point(str);
if (((loc = strstr(str,"LINESTRING")) != NULL) && (loc < parenth) )
return objects_inside_line(str);
if (((loc = strstr(str,"POLYGON")) != NULL) && (loc < parenth) )
return objects_inside_polygon(str);
return -1; //invalid
}
/****************************************************************************
* These functions actually parse the objects in the strings
* They all have arguments:
* obj_size[] -- size (in bytes) of each the sub-objects
* objs[][] -- list of pointers to the actual objects
* obj_types -- type of the sub-obj (see postgis.h)
* nobjs -- max number of sub-obj
* str -- actual string to parse from (start at begining)
* offset -- which sub-object # are we dealing with
* is3d -- are any of the points in the object 3d?
*
* basically, each of the functions will:
* + parse str to find the information required
* + allocate a new obj(s) and place it/them in objs to hold this info
* + set the obj_size for this/these sub-object
* + set the obj_type for this/these sub-object
* + increase offset so the next objects will go in the correct place
* + set is3d if there are any 3d points in the sub-object
* + return FALSE if an error occured
****************************************************************************/
//parse a point - make a new POINT3D object
bool parse_objects_inside_point(int32 *obj_size,char **objs, int32 *obj_types, int32 nobjs, char *str, int *offset, bool* is3d)
{
bool result;
if (*offset >= nobjs)
return FALSE; //too many objs found
objs[*offset] = palloc (sizeof(POINT3D) );
memset(objs[*offset], 0, sizeof(POINT3D) ); // zero memory
obj_types[*offset] = POINTTYPE;
obj_size[*offset] = sizeof(POINT3D);
str = strchr(str,'(');
if (str == NULL)
return FALSE; // parse error
//printf("about to parse the point\n");
result = parse_points_in_list_exact(str, (POINT3D*) objs[*offset] , 1, is3d);
//printf(" +point parsed\n");
*offset = *offset + 1;
return (result); // pass along any parse error
}
//parse a multipoint object - offset may increase by >1
// multiple sub object may be created
bool parse_objects_inside_multipoint(int32 *obj_size,char **objs, int32 *obj_types, int32 nobjs, char *str, int *offset, bool* is3d)
{
bool result;
int npoints;
int t;
POINT3D *pts;
// first find out how many points are in the multi-point
npoints = objects_inside_multipoint(str);
if (npoints <0)
return FALSE; // error in parsing (should have been caught before)
if (npoints ==0)
return TRUE; //no points, no nothing
if (*offset >= nobjs)
return FALSE; //too many objs found dont do anything, relay error
str = strchr(str,'(');
if (str == NULL)
return FALSE;
//allocate all the new objects
pts = palloc( sizeof(POINT3D) * npoints);
for (t=0;t make it two on top of each other
if (*offset >= nobjs)
return FALSE; //too many objs found
//how many points are in this linestring?
num_points = numb_points_in_list(str);
if (num_points == 0)
return FALSE;
if (num_points == 1) //not really a line
{
num_points = 2;
add_point = TRUE;
}
// -1 because object already has 1 point in it
objs[*offset] = palloc (sizeof(LINE3D) + sizeof(POINT3D)*(num_points-1) );
memset(objs[*offset], 0, sizeof(LINE3D) + sizeof(POINT3D)*(num_points-1) ); // zero memory
obj_types[*offset] = LINETYPE;
obj_size[*offset] = sizeof(LINE3D) + sizeof(POINT3D)*(num_points-1) ;
str = strchr(str,'(');
if (str == NULL)
return FALSE;
( (LINE3D *) objs[*offset] )->npoints = num_points;
if (add_point)
{
result = parse_points_in_list_exact(str, &(( (LINE3D*) objs[*offset]) ->points[0]) , num_points-1, is3d);
}
else
{
result = parse_points_in_list_exact(str, &(( (LINE3D*) objs[*offset]) ->points[0]) , num_points, is3d);
}
if (add_point)
{
memcpy( &(( (LINE3D*) objs[*offset]) ->points[1]) , &(( (LINE3D*) objs[*offset]) ->points[0]) , sizeof(POINT3D) );
}
*offset = *offset + 1;
return (result);
}
//parse a multi-line. For each sub-linestring, call the parse_objects_inside_line() function
// 'MULTILINESTRING((3 4 5,1 2 3,5 6 0),(1 2 0,4 5 0,6 7 0,99 99 0))'
// first scan to the second "(" - this is the begining of the first linestring.
// scan it, then move to the second linestring
bool parse_objects_inside_multiline(int32 *obj_size,char **objs, int32 *obj_types, int32 nobjs, char *str, int *offset, bool* is3d)
{
bool result;
int num_lines;
int t;
//how many lines are there?
num_lines = objects_inside_multiline(str);
if (num_lines <0)
return FALSE;
if (num_lines ==0)
return TRUE; //can be nothing
if (*offset >= nobjs)
return FALSE; //too many objs found
str= strchr(str,'('); //first one
if (str != NULL)
str++;
str= strchr(str,'('); //2nd one
if (str == NULL)
return FALSE; // couldnt find it
for (t=0;t= nobjs)
return FALSE; //too many objs found
//find out how many rings there are
num_rings = find_outer_list_length(str);
if (num_rings <1)
return FALSE; // must have at least one ring
//allocate space for how many points in each ring
npoints = palloc( sizeof(int32) * num_rings);
//find out how many points are in each sub-list (ring)
result = points_per_sublist(str,npoints, num_rings);
//how many points are inside this polygon in total?
sum_points =0;
for(t=0; t< num_rings ; t++)
{
sum_points += npoints[t];
if (npoints[t] <3)
{
elog(ERROR,"polygon has ring with <3 points.");
pfree(npoints);
return FALSE;
}
}
//now we can allocate the structure
// -1 because the POLYGON3D already has space for 1 ring with 1 point
// 4 is for possible double-word alignment
size = sizeof(POLYGON3D) + sizeof(int32)*(num_rings-1) +4+ sizeof(POINT3D)*(sum_points-1) ;
objs[*offset] = palloc (size);
memset(objs[*offset], 0, size ); // zero memory
polygon = (POLYGON3D *) objs[*offset];
obj_types[*offset] = POLYGONTYPE;
obj_size[*offset] = size;
str = strchr(str,'(');
if (str == NULL)
{
pfree(npoints);
return FALSE;
}
str++;
polygon->nrings = num_rings;
pts = (POINT3D *) &(polygon->npoints[num_rings]); //pts[] is just past the end of npoints[]
// make sure its double-word aligned
pts = (POINT3D *) MAXALIGN(pts);
//printf("POLYGON is at %p, size is %i, pts is at %p (%i)\n",objs[*offset],size, pts, ((void *) pts) - ((void *)objs[*offset]) );
//printf("npoints[0] is at %p, num_rings=%i\n", &(((POLYGON3D *) objs[*offset])->npoints[0] ), num_rings );
points_offset = 0;
for(t=0;tnpoints[t] = npoints[t]; // set # pts in this ring
//use exact because it will screw up otherwise
//printf("about to parse the actual points in ring #%i with %i points:\n",t,npoints[t]);
result = parse_points_in_list_exact(str,
&pts[points_offset],
npoints[t], is3d);
//printf(" +done parsing points\n");
//printf("1st points in ring is: [%g,%g,%g]\n", pts[points_offset].x ,pts[points_offset].y ,pts[points_offset].z );
if (!(result))
{
pfree(npoints);
return FALSE; //relay error
}
//first and last point are the same
if (! (FPeq(pts[points_offset].x , pts[points_offset + npoints[t]-1].x )
&&FPeq(pts[points_offset].y , pts[points_offset + npoints[t]-1].y )
&&FPeq(pts[points_offset].z , pts[points_offset + npoints[t]-1].z ) ) )
{
elog(ERROR,"polygon has ring where first point != last point");
pfree(npoints);
return FALSE; //invalid poly
}
points_offset += npoints[t]; //where to stick points in the next ring
str = strchr(str,'('); // where is the next ring
if (str == NULL)
{
pfree(npoints);
return FALSE; //relay parse error
}
str++;
}
pfree(npoints);
*offset = *offset + 1;
return (result);
}
// MULTIPOLYGON (( (3 4 5,1 2 3,5 6),(1 2, 4 5, 6 7) ), ( (11 11, 22 22, 33 33),(44 44, 55 55, 66 66) ) )'
// pass off work to parse_objects_inside_polygon()
bool parse_objects_inside_multipolygon(int32 *obj_size,char **objs, int32 *obj_types, int32 nobjs, char *str, int *offset, bool* is3d)
{
bool result;
int num_polys;
int t;
num_polys = objects_inside_multipolygon(str); //how many polygons are inside me?
//printf("parse_objects_inside_multipolygon('%s')\n",str);
if (num_polys <0)
return FALSE;
if (num_polys ==0)
return TRUE; //ask for nothing, get nothing
if (*offset >= nobjs)
return FALSE; //too many objs found
str= strchr(str,'('); //first one (begining of list of polys)
if (str != NULL)
{
str++;
str= strchr(str,'('); //2nd one (beginning of 1st poly)
}
if (str == NULL)
return FALSE; //relay error
for (t=0;tLLB.x = pt->x;
the_box->LLB.y = pt->y;
the_box->LLB.z = pt->z;
the_box->URT.x = pt->x;
the_box->URT.y = pt->y;
the_box->URT.z = pt->z;
return the_box;
}
// box encloses all the points in all the rings
BOX3D *bbox_of_polygon(POLYGON3D *polygon)
{
BOX3D *the_box ;
int numb_points =0,i;
POINT3D *pts,*pt;
for (i=0; i