PostGIS är en utökning till PostgreSQL-objektrelationsdatabassystemet som gör att GIS-objekt (geografiska informationssystem) kan lagras i databasen. PostGIS inkluderar stöd för GiST-baserade R-Tree spatiala index och funktioner för analys och bearbetning av GIS-objekt.
Detta är manualen för version 3.7.0beta1
Detta arbete är licensierat under en Creative Commons Attribution-Share Alike 3.0-licens. Du är välkommen att använda detta material på vilket sätt du vill, men vi ber dig att ange PostGIS Project som källa och om möjligt en länk tillbaka till https://postgis.net..
PostGIS extends PostgreSQL so that geospatial data can be stored, indexed, queried, and processed in the database. It keeps location data beside ordinary relational data, so a spatial query can use the same SQL, transactions, constraints, access controls, backup tools, and application connections as the rest of a PostgreSQL database.
The main postgis extension adds:
geometry for planar coordinate systems and geography for geodetic coordinates on the earth.
Spatial indexes that let the PostgreSQL planner avoid scanning every row when objects can be filtered by location.
Functions for measurement, relationships, overlays, geometry construction and editing, coordinate transformation, clustering, and spatial data exchange.
Support for common geospatial encodings and formats, including WKT, WKB, GeoJSON, GML, KML, FlatGeobuf, Geobuf, and Mapbox Vector Tiles.
This makes PostgreSQL a spatial database: applications can ask both ordinary questions and location-aware questions without moving data to a separate GIS processing system. Desktop GIS, map servers, ETL tools, and application frameworks can connect through normal PostgreSQL interfaces.
This manual documents the main PostGIS source distribution. Depending on how PostGIS was built and packaged, it can provide several PostgreSQL extensions and command-line tools:
postgisThe core geometry and geography types, spatial indexes, and most spatial functions.
postgis_rasterRaster storage, analysis, loading, and export. Raster support uses GDAL and can be omitted from a build.
postgis_topologySQL/MM topology types and functions for models based on shared nodes, edges, and faces.
postgis_sfcgalAdditional 2D and 3D processing functions backed by the optional SFCGAL library.
shp2pgsql, pgsql2shp, and raster2pgsql move data between common file formats and PostGIS. Other utilities support upgrades, profiling, and development.
The source tree also contains internal libraries such as liblwgeom and libpgcommon. They are implementation layers shared by PostGIS components, not separately released PostgreSQL extensions. Most users start by enabling the core extension with CREATE EXTENSION postgis; see Kapitel 2, Installation av PostGIS for available components and build options.
This manual covers the main postgis/postgis distribution. The official PostGIS source organization also hosts or mirrors complementary projects. These projects have their own release cycles, installation instructions, and documentation; installing the core extension does not install them.
Address Standardizer parses and normalizes postal addresses. It moved from the main PostGIS source tree to a separate repository for the PostGIS 3.7 development cycle.
PostGIS TIGER Geocoder provides United States address geocoding and reverse geocoding using Census TIGER data. It is also maintained separately from the main distribution.
H3-pg provides PostgreSQL bindings for the H3 hierarchical hexagonal indexing system and interoperates with PostGIS.
PostGIS Java provides Java bindings for PostGIS types.
Introduction to PostGIS is the hands-on workshop maintained by the PostGIS project.
Other PostgreSQL spatial extensions can complement PostGIS while remaining independent projects. For example, pgRouting adds routing and graph analysis. Use each project's own manual for its functions and support policy.
The manual is both a guide to the PostGIS data model and the complete reference for the SQL interface. Choose a starting point based on what you are trying to do:
Start with the Introduction to PostGIS workshop for a tutorial, then use Kapitel 4, Datahantering to understand spatial types, coordinate systems, validity, loading, and indexes.
Read Kapitel 2, Installation av PostGIS and Kapitel 3, PostGIS-administration. Package-specific instructions and supported release information are maintained on the PostGIS website.
Read Kapitel 5, Spatiala frågor for spatial relationships and index-aware query patterns, and Kapitel 6, Tips om prestanda for common performance problems.
Use Kapitel 7, PostGIS-referens or Kapitel 13, Index över specialfunktioner i PostGIS. Function pages state accepted types, dimensional support, standards conformance, dependency requirements, and version availability.
See Kapitel 9, Topologi, Kapitel 10, Rasterdatahantering, frågor och applikationer, Kapitel 11, Referens för raster, or Kapitel 8, SFCGAL Funktioner Referens.
Collect the versions reported by PostGIS_Full_Version and follow Kapitel 14, Rapportering av problem. Check Appendix A, Anteckningar för release when behavior differs between release lines.
This manual marks individual functions as compliant with spatial standards so users can tell which behavior is portable and which behavior is a PostGIS extension. PostGIS implements the OGC Simple Features for SQL model, including the geometry type, Well-Known Text (WKT), Well-Known Binary (WKB), and the common spatial accessors, constructors, predicates, and processing functions. PostGIS also implements many SQL/MM Spatial types and functions.
PostGIS supports geometry families defined by later standards, including SQL/MM curved geometry and OGC Simple Features Access 1.2 PolyhedralSurface, Triangle, and TIN. Support for these geometry families is function-specific, and each function page documents the supported input types and conformance level.
PostGIS also includes widely used extensions and integrations. Examples of PostGIS extensions include Extended WKT (EWKT), Extended WKB (EWKB), SRID metadata in those extended formats, geography, and raster. PostGIS also supports input and output exchange formats defined by other standards, such as GeoJSON, GML, and KML. These features are documented individually and should not be read as OGC Simple Features or SQL/MM requirements unless the specific function or format says so.
When the implementation intentionally differs from a standard, or when a standard leaves behavior ambiguous, the relevant function page describes the PostGIS behavior. Kapitel 13, Index över specialfunktioner i PostGIS summarizes SQL/MM compliance and geometry-type support across functions.
PostGIS began in 2001 as a spatial database research project at Refractions Research. It is now an OSGeo project developed by contributors and organizations around the world. The Project Steering Committee coordinates releases, project policy, and the general direction of development. The complete contributor and sponsor record is in Kapitel 15, Credits and Acknowledgments at the end of this manual.
The manual is the authoritative reference for the released SQL interface. The project website and source tree provide the surrounding material:
Documentation routes readers to getting-started instructions, versioned manuals, tips, training material, and the FAQ.
Community lists mailing lists, chat, events, videos, and other support channels.
Developer documentation covers development environments, testing, coding style, internals, maintenance, governance, releases, and website work.
I detta kapitel beskrivs de steg som krävs för att installera PostGIS.
För att kompilera förutsatt att du har alla beroenden i din sökväg:
tar -xvzf postgis-3.7.0beta1.tar.gz cd postgis-3.7.0beta1 ./configure make make install
När PostGIS har installerats måste det aktiveras (Avsnitt 3.3, ”Skapa spatiala databaser”) eller uppgraderas (Avsnitt 3.4, ”Uppgradering av spatiala databaser”) i varje enskild databas som du vill använda det i.
![]() | |
Många OS-system innehåller nu förbyggda paket för PostgreSQL / PostGIS. I många fall är kompilering endast nödvändig om du vill ha de mest blödande kantversionerna eller om du är en paketunderhållare. Detta avsnitt innehåller allmänna kompileringsinstruktioner, om du kompilerar för Windows etc eller ett annat operativsystem kan du hitta ytterligare mer detaljerad hjälp i PostGIS User Contributed Compile Guides och PostGIS Dev Wiki. Förbyggda paket för olika operativsystem finns listade i PostGIS förbyggda paket Om du är en Windows-användare kan du få stabila builds via Stackbuilder eller PostGIS Windows nedladdningssida Vi har också mycket blödande avancerade Windows experimentella builds som byggs vanligtvis en eller två gånger i veckan eller när något spännande händer. Du kan använda dessa för att experimentera med de pågående utgåvorna av PostGIS |
PostGIS-modulen är en utökning av PostgreSQL-backendservern. Som sådan kräver PostGIS & last_release_version; full tillgång till PostgreSQL-serverhuvud för att kunna kompilera. Det kan byggas mot PostgreSQL-versioner &min_postgres_version; - &max_postgres_version;. Tidigare versioner av PostgreSQL stöds inte..
Se installationsguiderna för PostgreSQL om du inte redan har installerat PostgreSQL. https://www. postgresql.org .
![]() | |
För GEOS-funktionalitet, när du installerar PostgreSQL kan du behöva länka PostgreSQL uttryckligen mot standard C ++ -biblioteket: |
LDFLAGS=-lstdc++ ./configure [YOUR OPTIONS HERE]
Detta är en lösning för felaktiga C++-undantag i äldre utvecklingsverktyg. Om du upplever konstiga problem (backend oväntat stängd eller liknande saker) kan du prova det här tricket. Detta kommer naturligtvis att kräva omkompilering av din PostgreSQL från grunden.
Följande steg beskriver konfiguration och kompilering av PostGIS-källan. De är skrivna för Linux-användare och kommer inte att fungera på Windows eller Mac.
Hämta källarkivet för PostGIS från nedladdningswebbplatsen https://download.osgeo.org/postgis/source/postgis-3.7.0beta1.tar.gz
wget https://download.osgeo.org/postgis/source/postgis-3.7.0beta1.tar.gz tar -xvzf postgis-3.7.0beta1.tar.gz cd postgis-3.7.0beta1
Detta kommer att skapa en katalog som heter postgis-&last_release_version; i den aktuella arbetskatalogen.
Alternativt kan du hämta källkoden från git-förrådet https://git.osgeo.org/gitea/postgis/postgis/ .
git clone https://git.osgeo.org/gitea/postgis/postgis.git postgis
cd postgis
sh autogen.sh
Byt till den nyskapade postgis-katalogen för att fortsätta installationen.
./configure
PostGIS har följande krav för uppbyggnad och användning:
Obligatorisk
PostgreSQL 14 - 18. En fullständig installation av PostgreSQL (inklusive serverhuvuden) krävs. PostgreSQL finns tillgängligt på https://www.postgresql.org 18 .
For current release-line support and end-of-life policy, see https://postgis.net/development/versions_eol/
GNU C-kompilator(gcc). Vissa andra ANSI C-kompilatorer kan användas för att kompilera PostGIS, men vi hittar mycket färre problem när vi kompilerar med gcc.
GNU Make(gmake eller make). För många system är GNU make standardversionen av make. Kontrollera versionen genom att anropa make -v. Andra versioner av make kanske inte bearbetar PostGIS Makefile på rätt sätt.
Proj reprojektionsbibliotek. Proj 6.1 eller senare krävs. Proj-biblioteket används för att tillhandahålla stöd för koordinatreprojektion inom PostGIS. Proj finns tillgängligt för nedladdning från https://proj.org/ . .
GEOS geometribibliotek, version 3.8.0 eller högre, men GEOS 3.14+ krävs för att kunna utnyttja alla nya funktioner och egenskaper fullt ut. GEOS finns tillgängligt för hämtning från https://libgeos.org .
LibXML2, version 2.5.x eller högre. LibXML2 används för närvarande i vissa importfunktioner (ST_GeomFromGML och ST_GeomFromKML). LibXML2 finns att ladda ner från https://gitlab.gnome.org/GNOME/libxml2/-/releases..
JSON-C, version 0.9 eller högre. JSON-C används för närvarande för att importera GeoJSON via funktionen ST_GeomFromGeoJson. JSON-C finns tillgängligt för nedladdning från https://github.com/json-c/json-c/releases/.
The GNU Multiple Precision Arithmetic Library (libgmp). Used to control precision of math operations in PostGIS Topology. GMP is available for download from https://gmplib.org/.
GDAL, version 3+ är att föredra. Detta krävs för rasterstöd. https://gdal.org/download.html.
Om du kompilerar med PostgreSQL + JIT krävs LLVM-version >=6 https://trac.osgeo.org/postgis/ticket/4125.
Valfritt
GDAL (pseudo-valfritt) endast om du inte vill ha raster kan du utelämna det. Se också till att aktivera de drivrutiner som du vill använda enligt beskrivningen i Avsnitt 3.2, ”Konfigurera stöd för raster”.
GTK (kräver GTK+2.0, 2.8+) för att kompilera shp2pgsql-gui shape-filinläsaren. http://www. gtk.org/ .
SFCGAL, 1.4.1 or higher is required, 2.3+ is needed to be able to use all functionality. SFCGAL can be used to provide additional 2D and 3D advanced analysis functions to PostGIS cf Kapitel 8, SFCGAL Funktioner Referens. https://sfcgal.gitlab.io/sfcgal/.
För att aktivera ST_AsMVT krävs protobuf-c-biblioteket 1.1.0 eller högre (för användning) och protoc-c-kompilatorn (för byggande). Dessutom krävs pkg-config för att verifiera den korrekta minimiversionen av protobuf-c. Se protobuf-c. Som standard kommer Postgis att använda Wagyu för att validera MVT-polygoner snabbare, vilket kräver en c++11-kompilator. Den kommer att använda CXXFLAGS och samma kompilator som PostgreSQL-installationen. För att inaktivera detta och använda GEOS istället använder du --without-wagyu under konfigurationssteget.
CUnit(CUnit). Detta behövs för regressionstestning. http://cunit.sourceforge.net/
DocBook(xsltproc) krävs för att bygga upp dokumentationen. Docbook finns tillgängligt från http://www.docbook.org/ .
DBLatex(dblatex) krävs för att skapa dokumentationen i PDF-format. DBLatex är tillgängligt från http://dblatex.sourceforge.net/ .
PDF documentation needs an SVG rasterizer for its high-resolution figure fallbacks. The build prefers rsvg-convert, and can also use GraphicsMagick (gm convert) or ImageMagick (magick or convert).
Som med de flesta Linux-installationer är det första steget att generera den Makefile som ska användas för att bygga källkoden. Detta görs genom att köra skalskriptet
./configure
Utan ytterligare parametrar försöker detta kommando att automatiskt hitta de komponenter och bibliotek som behövs för att bygga PostGIS-källkoden på ditt system. Även om detta är den vanligaste användningen av ./configure, accepterar skriptet flera parametrar för dem som har de nödvändiga biblioteken och programmen på icke-standardiserade platser.
I följande lista visas endast de vanligaste parametrarna. För en fullständig lista, använd parametrarna --help eller --help=short.
--with-library-minor-versionFrån och med PostGIS 3.0 kommer de biblioteksfiler som genereras som standard inte längre att ha den mindre versionen som en del av filnamnet. Detta innebär att alla PostGIS 3-bibliotek kommer att sluta på postgis-3. Detta gjordes för att göra pg_upgrade enklare, med nackdelen att du bara kan installera en version av PostGIS 3-serien på din server. För att få det gamla beteendet för filen inklusive den mindre versionen: t.ex. postgis-3.0 lägg till denna switch i din configure-sats.
--prefix=PREFIXThis is the installation prefix for PostGIS command-line utilities. By default, utilities are installed in the executable directory reported by the detected PostgreSQL installation.
![]() | |
PostgreSQL extension files are installed in the directories reported by pg_config, so the server can load them. This includes the PostGIS shared library and SQL extension files. Use |
--with-pgconfig=FILEPostgreSQL tillhandahåller ett verktyg som heter pg_config för att göra det möjligt för tillägg som PostGIS att hitta PostgreSQL-installationskatalogen. Använd den här parametern(--with-pgconfig=/path/to/pg_config) för att manuellt ange en viss PostgreSQL-installation som PostGIS kommer att bygga mot.
--with-gdalconfig=FILEGDAL, ett obligatoriskt bibliotek, tillhandahåller funktionalitet som behövs för rasterstöd gdal-config för att göra det möjligt för programvaruinstallationer att hitta GDAL-installationskatalogen. Använd denna parameter(--with-gdalconfig=/path/to/gdal-config) för att manuellt ange en viss GDAL-installation som PostGIS ska bygga mot.
--with-geosconfig=FILEGEOS, ett nödvändigt geometribibliotek, tillhandahåller ett verktyg som heter geos-config för att göra det möjligt för programvaruinstallationer att hitta GEOS installationskatalog. Använd denna parameter(--with-geosconfig=/path/to/geos-config) för att manuellt ange en viss GEOS-installation som PostGIS ska bygga mot.
--with-xml2config=FILELibXML är det bibliotek som krävs för att göra GeomFromKML/GML-processer. Det hittas normalt om du har libxml installerat, men om inte eller om du vill att en specifik version ska användas, måste du peka PostGIS mot en specifik xml2-config confi-fil för att göra det möjligt för programvaruinstallationer att hitta LibXML-installationskatalogen. Använd denna parameter(>--with-xml2config=/path/to/xml2-config) för att manuellt ange en viss LibXML-installation som PostGIS ska bygga mot.
--with-projdir=DIRProj är ett reprojektionsbibliotek som krävs av PostGIS. Använd denna parameter(--with-projdir=/path/to/projdir) för att manuellt ange en viss Proj-installationskatalog som PostGIS ska bygga mot.
--with-libiconv=DIRKatalog där iconv är installerat.
--with-jsondir=DIRJSON-C är ett MIT-licensierat JSON-bibliotek som krävs för PostGIS ST_GeomFromJSON-stöd. Använd denna parameter(--with-jsondir=/path/to/jsondir) för att manuellt ange en viss JSON-C-installationskatalog som PostGIS kommer att bygga mot.
--with-guiKompilera GUI för dataimport (kräver GTK+2.0). Detta kommer att skapa shp2pgsql-gui grafiskt gränssnitt till shp2pgsql.
--without-rasterKompilera utan stöd för raster.
--without-topologyKompilera utan topologistöd.
--with-gettext=noSom standard kommer PostGIS att försöka upptäcka stöd för gettext och kompilera med det, men om du stöter på inkompatibilitetsproblem som orsakar att laddaren bryts kan du inaktivera det helt med det här kommandot. Se biljett http://trac.osgeo.org/postgis/ticket/748 för ett exempel på ett problem som löstes genom att konfigurera med detta. OBS: att du inte missar mycket genom att stänga av detta. Detta används för internationell hjälp/etikettstöd för GUI-laddaren som ännu inte är dokumenterad och fortfarande experimentell.
--with-sfcgal=PATHSom standard kommer PostGIS inte att installeras med sfcgal-stöd utan denna switch. PATH är ett valfritt argument som gör det möjligt att ange en alternativ PATH till sfcgal-config.
--without-phony-revisionInaktivera uppdatering av postgis_revision.h för att matcha aktuell HEAD i git-arkivet.
![]() | |
Om du har hämtat PostGIS från kodförvaret är det första steget verkligen att köra skriptet |
./autogen.sh
Detta skript kommer att generera configure-skriptet som i sin tur används för att anpassa installationen av PostGIS.
Om du istället fick PostGIS som en tarball är det inte nödvändigt att köra ./autogen.sh eftersom configure redan har genererats.
När Makefile har genererats är det enkelt att bygga PostGIS genom att köra
make
[last line of output] PostGIS was built successfully. Ready to install.
All the functions have comments generated from the documentation. If you wish to install these comments into your spatial databases later, run the command which requires docbook. The postgis_comments.sql and other package comment files are also packaged in the tar.gz distribution in the doc folder so no need to make comments if installing from the tar ball. Comments are also included as part of the CREATE EXTENSION install.
make comments
The make cheatsheets target generates html cheat sheets suitable for quick reference or for student handouts. This requires xsltproc to build and will generate 4 files in doc folder topology_cheatsheet.html, raster_cheatsheet.html, postgis_cheatsheet.html
Du kan ladda ner några förbyggda tillgängliga i html och pdf från PostGIS / PostgreSQL Study Guides
make cheatsheets
The PostGIS extensions are built and installed automatically when PostgreSQL extension support is available.
Om du bygger från källkatalogen måste du först bygga funktionsbeskrivningarna. Dessa byggs om du har docbook installerat. Du kan också bygga manuellt med uttalandet:
make comments
Det är inte nödvändigt att bygga kommentarerna om du bygger från en release-tarball eftersom dessa redan är färdigbyggda med tarballen.
Tilläggen bör automatiskt byggas som en del av make-installationsprocessen. Du kan vid behov bygga från tilläggsmapparna eller kopiera filer om du behöver dem på en annan server.
Set PGUSER if you need to override the psql connection user, then test before installing. After installation, run the extension regression tests.
cd extensions cd postgis make clean make export PGUSER=postgres make check make install make check RUNTESTFLAGS=--extension
![]() | |
|
Tilläggsfilerna kommer alltid att vara desamma för samma version av PostGIS och PostgreSQL oavsett operativsystem, så det går bra att kopiera över tilläggsfilerna från ett operativsystem till ett annat så länge du har PostGIS-binärerna redan installerade på dina servrar.
Om du vill installera tillägg manuellt på en separat server som skiljer sig från din utveckling måste du kopiera följande filer från tilläggsmappen till mappen PostgreSQL / share / extension i din PostgreSQL-installation samt de nödvändiga binärerna för vanlig PostGIS om du inte redan har dem på servern.
Det här är kontrollfilerna som anger information som t.ex. vilken version av tillägget som ska installeras om det inte anges. postgis.control, postgis_topology.control.
Alla filer i mappen /sql för varje tillägg. Observera att dessa måste kopieras till roten till PostgreSQL share/extension-mappen extensions/postgis/sql/*.sql, extensions/postgis_topology/sql/*.sql
När du har gjort det bör du se postgis, postgis_topology som tillgängliga tillägg i PgAdmin -> tillägg.
Om du använder psql kan du kontrollera att tilläggen är installerade genom att köra den här frågan:
SELECT name, default_version, installed_version FROM pg_available_extensions WHERE name LIKE 'postgis%' ORDER BY name;
┌──────────────────┬─────────────────┬───────────────────┐ │ name │ default_version │ installed_version │ ├──────────────────┼─────────────────┼───────────────────┤ │ postgis │ 3.7.0beta1 │ 3.7.0beta1 │ │ postgis_raster │ 3.7.0beta1 │ 3.7.0beta1 │ │ postgis_sfcgal │ 3.7.0beta1 │ │ │ postgis_topology │ 3.7.0beta1 │ │ └──────────────────┴─────────────────┴───────────────────┘
Om du har tillägget installerat i den databas du frågar kommer du att se ett omnämnande i kolumnen installed_version. Om du inte får några poster tillbaka betyder det att du inte har några postgis-tillägg installerade på servern alls. PgAdmin III 1.14+ kommer också att tillhandahålla denna information i tilläggsavsnittet i databasbläddrarträdet och kommer till och med att tillåta uppgradering eller avinstallation genom att högerklicka.
Om du har tilläggen tillgängliga kan du installera postgis-tillägget i din valfria databas genom att antingen använda pgAdmin-tilläggsgränssnittet eller köra dessa sql-kommandon:
CREATE EXTENSION postgis; CREATE EXTENSION postgis_raster; CREATE EXTENSION postgis_sfcgal; CREATE EXTENSION postgis_topology;
I psql kan du använda för att se vilka versioner du har installerat och även vilket schema de är installerade.
\connect mygisdb \x \dx postgis*
List of installed extensions ┌─[ RECORD 1 ]────────────────────────────────────────────────┐ │ Name │ postgis │ │ Version │ 3.7.0beta1 │ │ Schema │ public │ │ Description │ PostGIS geometry, geography, and raster… │ ├─[ RECORD 2 ]────────────────────────────────────────────────┤ │ Name │ postgis_raster │ │ Version │ 3.7.0beta1 │ │ Schema │ public │ │ Description │ PostGIS raster types and functions │ ├─[ RECORD 3 ]────────────────────────────────────────────────┤ │ Name │ postgis_topology │ │ Version │ 3.7.0beta1 │ │ Schema │ topology │ │ Description │ PostGIS topology spatial types and functions │ └─────────────────────────────────────────────────────────────┘
![]() | |
Extension tables |
Om du installerade 3.7.0beta1, utan att använda vårt underbara utökningssystem, kan du ändra det till att vara utökningsbaserat genom att köra kommandona nedan för att paketera funktionerna i deras respektive utökning. Installation med `unpackaged` togs bort i PostgreSQL 13, så du rekommenderas att byta till en utökningsbyggnad innan du uppgraderar till PostgreSQL 13.
CREATE EXTENSION postgis FROM unpackaged; CREATE EXTENSION postgis_raster FROM unpackaged; CREATE EXTENSION postgis_topology FROM unpackaged;
Om du vill testa PostGIS-bygget kör du
make check
Ovanstående kommando kommer att köra igenom olika kontroller och regressionstester med hjälp av det genererade biblioteket mot en faktisk PostgreSQL-databas.
![]() | |
Om du konfigurerade PostGIS med icke-standardiserade PostgreSQL-, GEOS- eller Proj-platser kan du behöva lägga till deras biblioteksplatser i miljövariabeln |
![]() | |
För närvarande förlitar sig make-kontrollen på |
![]() | |
Sandboxed build accounts that are not PostgreSQL superusers can delegate database ownership during the regression cycle by exporting These variables allow automated environments to exercise the full upgrade and extension install paths without promoting the calling account to superuser, provided the target PostgreSQL instance permits extension installation by those delegate roles. |
Om make check lyckas kommer resultatet av nästan 500 tester att visas. Resultaten kommer att se ut ungefär som följande (många rader utelämnade nedan):
CUnit - A unit testing framework for C - Version 2.1-3
http://cunit.sourceforge.net/
.
.
.
Run Summary: Type Total Ran Passed Failed Inactive
suites 44 44 n/a 0 0
tests 300 300 300 0 0
asserts 4215 4215 4215 0 n/a
Elapsed time = 0.229 seconds
.
.
.
Running tests
.
.
.
Run tests: 134
Failed: 0
-- if you build with SFCGAL
.
.
.
Running tests
.
.
.
Run tests: 13
Failed: 0
-- if you built with raster support
.
.
.
Run Summary: Type Total Ran Passed Failed Inactive
suites 12 12 n/a 0 0
tests 65 65 65 0 0
asserts 45896 45896 45896 0 n/a
.
.
.
Running tests
.
.
.
Run tests: 101
Failed: 0
-- topology regress
.
.
.
Running tests
.
.
.
Run tests: 51
Failed: 0
-- if you built --with-gui, you should see this too
CUnit - A unit testing framework for C - Version 2.1-2
http://cunit.sourceforge.net/
.
.
.
Run Summary: Type Total Ran Passed Failed Inactive
suites 2 2 n/a 0 0
tests 4 4 4 0 0
asserts 4 4 4 0 n/autdata bör se ut som:
============== dropping database "contrib_regression" ============== DROP DATABASE ============== creating database "contrib_regression" ============== CREATE DATABASE ALTER DATABASE ============== installing fuzzystrmatch ============== CREATE EXTENSION ============== installing postgis ============== CREATE EXTENSION ============== running regression test queries ============== test test-normalize_address ... ok ===================== All 2 tests passed. =====================
För att installera PostGIS skriver du
make install
Detta kommer att kopiera PostGIS-installationsfilerna till lämplig underkatalog som anges av konfigurationsparametern --prefix. I synnerhet:
Binärfilerna för laddaren och dumpern installeras i [prefix]/bin.
SQL-filerna, till exempel postgis.sql, installeras i [prefix]/share/contrib.
PostGIS-biblioteken är installerade i [prefix]/lib.
Om du tidigare körde kommandot make comments för att generera filen postgis_comments.sql, raster_comments.sq l, installerar du sql-filen genom att köra
make comments-install
![]() | |
|
Det finns flera saker att kontrollera när installationen eller uppgraderingen inte går som du förväntat dig.
PostgreSQL version mismatch.
Kontrollera att du har installerat PostgreSQL 14 eller nyare, och att du kompilerar mot samma version av PostgreSQL-källan som den version av PostgreSQL som körs. Mix-ups kan uppstå när din (Linux) distribution redan har installerat PostgreSQL, eller om du annars har installerat PostgreSQL tidigare och glömt bort det. PostGIS fungerar bara med PostgreSQL 14 eller nyare, och konstiga, oväntade felmeddelanden kommer att resultera om du använder en äldre version. För att kontrollera vilken version av PostgreSQL som körs, anslut till databasen med psql och kör den här frågan:
SELECT version();
If you are running an RPM based distribution, you can check for the existence of pre-installed packages using the rpm command as follows:
rpm -qa | grep postgresql
Restoring an upgrade into a database without PostGIS.
Om uppgraderingen misslyckas, se till att du återställer till en databas som redan har PostGIS installerat.
SELECT PostGIS_Full_Version();
Kontrollera också att configure korrekt har upptäckt platsen och versionen av PostgreSQL, Proj-biblioteket och GEOS-biblioteket.
Utdata från configure används för att generera filen postgis_config.h. Kontrollera att variablerna POSTGIS_PGSQL_VERSION, POSTGIS_PROJ_VERSION och POSTGIS_GEOS_VERSION har ställts in korrekt.
Inställning för PostGIS-prestanda är ungefär som att ställa in för någon PostgreSQL-arbetsbelastning. Det enda ytterligare övervägandet är att geometrier och raster vanligtvis är stora, så minnesrelaterade optimeringar har i allmänhet större inverkan på PostGIS än andra typer av PostgreSQL-frågor.
För allmänna detaljer om optimering av PostgreSQL, se Tuning your PostgreSQL Server.
PostgreSQL configuration can be set at the server level without touching postgresql.conf or postgresql.auto.conf by using the ALTER SYSTEM command.
Set work_mem, reload the configuration so new connections use the change, and display the current value. Use SHOW ALL to list all settings.
ALTER SYSTEM SET work_mem = '256MB'; SELECT pg_reload_conf(); SHOW work_mem;
Förutom Postgres-inställningarna har PostGIS några anpassade inställningar som listas i Avsnitt 7.22, ”Grand Unified Custom Variables (GUC)”.
Dessa inställningar konfigureras i postgresql.conf::
Standard: partition
This is generally used for table partitioning. The default of "partition" forces the planner to only analyze tables for constraint consideration if they are in an inherited hierarchy and avoids paying the planner penalty otherwise.
Default: ~128MB
Ställ in på ca 25% to 40% of tillgängligt RAM-minne. På Windows kanske du inte kan ställa in så högt.
max_worker_processes controls the maximum number of background processes available to the server and therefore also bounds how many workers can participate in parallel queries.
Standard: 8
Ställer in det maximala antalet bakgrundsprocesser som systemet kan stödja. Denna parameter kan endast ställas in vid serverstart.
work_mem - anger storleken på det minne som används för sorteringsoperationer och komplexa frågor
Standard: 1-4MB
Justera upp för stora databaser, komplexa frågor, mycket RAM
Justera ner för många samtidiga användare eller lågt RAM-minne.
Om du har mycket RAM-minne och få utvecklare:
SET work_mem TO '256MB';
maintenance_work_mem - den minnesstorlek som används för VACUUM, CREATE INDEX etc.
Standard: 16-64 MB
Generellt för låg - binder upp I/O, låser objekt medan minne byts ut
Rekommenderar 32 MB till 1 GB på produktionsservrar med mycket RAM, men det beror på antalet samtidiga användare. Om du har mycket RAM och få utvecklare:
SET maintenance_work_mem TO '1GB';
max_parallel_workers_per_gather
Parallel query support in modern PostgreSQL and PostGIS uses this setting to decide how many workers a plan may request. If set to higher than 0, then some queries such as those involving relation functions like ST_Intersects can use multiple processes and can run more than twice as fast when doing so. If you have a lot of processors to spare, you should change the value of this to as many processors as you have. Also make sure to bump up max_worker_processes to at least as high as this number.
Standard: 0
Ställer in det maximala antalet arbetare som kan startas av en enda Gather-nod. Parallella arbetare hämtas från den pool av processer som fastställs av max_worker_processes. Observera att det begärda antalet arbetare kanske inte är tillgängligt vid körningstillfället. Om detta inträffar kommer planen att köras med färre arbetare än förväntat, vilket kan vara ineffektivt. Om detta värde sätts till 0, vilket är standard, inaktiveras parallell frågeexekvering.
Om du har aktiverat rasterstöd kan du läsa nedan om hur du konfigurerar det på rätt sätt.
Out-of-db rasters and all raster drivers are disabled by default. In order to re-enable these, you need to set the following environment variables POSTGIS_GDAL_ENABLED_DRIVERS and POSTGIS_ENABLE_OUTDB_RASTERS in the server environment. You can also use the more cross-platform approach of setting the corresponding Avsnitt 7.22, ”Grand Unified Custom Variables (GUC)”.
Om du vill aktivera offline-raster:
POSTGIS_ENABLE_OUTDB_RASTERS=1
Alla andra inställningar eller ingen inställning alls inaktiverar raster utanför databasen.
För att aktivera alla GDAL-drivrutiner som finns tillgängliga i din GDAL-installation, ställ in denna miljövariabel enligt följande
POSTGIS_GDAL_ENABLED_DRIVERS=ENABLE_ALL
Om du endast vill aktivera specifika drivrutiner ställer du in din miljövariabel enligt följande:
POSTGIS_GDAL_ENABLED_DRIVERS="GTiff PNG JPEG GIF XYZ"
![]() | |
Om du använder Windows, använd inte citattecken för drivrutinslistan |
Setting environment variables varies depending on OS. For PostgreSQL installed on Ubuntu or Debian via apt-postgresql, the preferred way is to edit /etc/postgresql/ where the placeholders refer to the PostgreSQL major version and cluster name.MAJOR/CLUSTER/environment
I Windows, om du kör som en tjänst, kan du ställa in via systemvariabler som du hittar i Windows 7 genom att högerklicka på Dator->Egenskaper Avancerade systeminställningar eller i utforskaren genom att navigera till Kontrollpanelen\Alla kontrollpanelsalternativ\System. Klicka sedan på Avancerade systeminställningar ->Avancerat->Miljövariabler och lägg till nya systemvariabler.
När du har ställt in miljövariablerna måste du starta om din PostgreSQL-tjänst för att ändringarna ska träda i kraft.
If you have compiled and installed the extensions/postgis modules, you can turn a database into a spatial one using the EXTENSION mechanism.
Core postgis-tillägget inkluderar geometri, geografi, spatial_ref_sys och alla funktioner och kommentarer. Raster och topologi är paketerade som ett separat tillägg.
Kör följande SQL-snutt i den databas som du vill aktivera spatialt:
CREATE EXTENSION IF NOT EXISTS plpgsql; CREATE EXTENSION postgis; CREATE EXTENSION postgis_raster; -- OPTIONAL CREATE EXTENSION postgis_topology; -- OPTIONAL
![]() | |
Detta behövs i allmänhet bara om du inte kan eller inte vill få PostGIS installerat i PostgreSQL-tilläggskatalogen (till exempel under testning, utveckling eller i en begränsad miljö). |
Att lägga till PostGIS-objekt och funktionsdefinitioner i din databas görs genom att läsa in de olika sql-filerna som finns i [prefix]/share/contrib enligt specifikationerna under byggfasen.
De centrala PostGIS-objekten (geometri- och geograftyper och deras stödfunktioner) finns i skriptet postgis .sql. Rasterobjekt finns i skriptet rtpostgis.sql. Topologiobjekt finns i skriptet topology .sql.
För en fullständig uppsättning EPSG-koordinatsystemdefinitionsidentifierare kan du också läsa in definitionsfilen spatial_ref_sys.sql och fylla i tabellen spatial_ref_sys. Detta gör att du kan utföra ST_Transform()-operationer på geometrier.
Om du vill lägga till kommentarer till PostGIS-funktionerna kan du hitta dem i skriptet postgis_comments.sql. Kommentarer kan visas genom att helt enkelt skriva \dd [function_name] från ett psql-terminalfönster.
Kör följande Shell-kommandon i din terminal:
DB=[yourdatabase]
SCRIPTSDIR=`pg_config --sharedir`/contrib/postgis-3.6/
# Core objects
psql -d ${DB} -f ${SCRIPTSDIR}/postgis.sql
psql -d ${DB} -f ${SCRIPTSDIR}/spatial_ref_sys.sql
psql -d ${DB} -f ${SCRIPTSDIR}/postgis_comments.sql # OPTIONAL
# Raster support (OPTIONAL)
psql -d ${DB} -f ${SCRIPTSDIR}/rtpostgis.sql
psql -d ${DB} -f ${SCRIPTSDIR}/raster_comments.sql # OPTIONAL
# Topology support (OPTIONAL)
psql -d ${DB} -f ${SCRIPTSDIR}/topology.sql
psql -d ${DB} -f ${SCRIPTSDIR}/topology_comments.sql # OPTIONAL
Att uppgradera befintliga spatiala databaser kan vara svårt eftersom det kräver ersättning eller införande av nya PostGIS-objektdefinitioner.
Tyvärr är det inte alla definitioner som enkelt kan ersättas i en levande databas, så ibland är det bästa alternativet en dump/reload-process.
PostGIS tillhandahåller en SOFT UPGRADE-procedur för mindre eller bugfix-utgåvor och en HARD UPGRADE-procedur för större utgåvor.
Innan du försöker uppgradera PostGIS är det alltid värt att säkerhetskopiera dina data. Om du använder flaggan -Fc till pg_dump kommer du alltid att kunna återställa dumpningen vid en hård uppgradering.
Om du installerade din databas med hjälp av tillägg måste du också uppgradera med hjälp av tilläggsmodellen. Om du installerade med den gamla sql-skriptmetoden rekommenderas du att byta din installation till tillägg eftersom skriptmetoden inte längre stöds.
If you originally installed PostGIS with extensions, then you need to upgrade using extensions as well. Doing a minor upgrade with extensions is fairly painless.
Use the PostGIS_Extensions_Upgrade function to upgrade to the latest version you have installed.
SELECT postgis_extensions_upgrade();
If you are upgrading a database that still runs PostGIS 2.5, issue an ALTER EXTENSION followed by postgis_extensions_upgrade() to make sure the legacy postgis_raster objects are folded back into the main extension.
ALTER EXTENSION postgis UPDATE; SELECT postgis_extensions_upgrade();
This second call is needed to rebundle the postgis_raster extension.
SELECT postgis_extensions_upgrade();
Om du har flera versioner av PostGIS installerade och inte vill uppgradera till den senaste, kan du uttryckligen ange versionen på följande sätt:
ALTER EXTENSION postgis UPDATE TO "3.7.0beta1"; ALTER EXTENSION postgis_topology UPDATE TO "3.7.0beta1";
Om du får ett felmeddelande något i stil med:
No migration path defined for … to 3.7.0beta1
Sedan måste du säkerhetskopiera din databas, skapa en ny enligt beskrivningen i Avsnitt 3.3.1, ”Spatial aktivering av databas med hjälp av EXTENSION” och sedan återställa din säkerhetskopia ovanpå den nya databasen.
Om du får ett meddelande som:
Version "3.7.0beta1" of extension "postgis" is already installed
Då är allt redan uppdaterat och du kan tryggt ignorera det. OM du inte försöker uppgradera från en utvecklingsversion till nästa (som inte får ett nytt versionsnummer); i så fall kan du lägga till "next" till versionssträngen, och nästa gång måste du släppa "next"-suffixet igen:
ALTER EXTENSION postgis UPDATE TO "3.7.0beta1next";
ALTER EXTENSION postgis_topology UPDATE TO "3.7.0beta1next";![]() | |
Om du installerade PostGIS ursprungligen utan en angiven version kan du ofta hoppa över ominstallationen av postgis-tillägget innan du återställer eftersom säkerhetskopian bara har |
![]() | |
If you are upgrading PostGIS extension from a version prior to 3.0.0, you will have a new extension postgis_raster which you can safely drop, if you don't need raster support. |
DROP EXTENSION postgis_raster;
Extensions have been the supported installation method for many releases. If you still rely on an unpackaged installation, perform a HARD UPGRADE into a database created with extensions and migrate your data there.
Med HÅRD UPPGRADERING menar vi fullständig dumpning/omladdning av PostGIS-aktiverade databaser. Du behöver en HÅRD UPPGRADERING när PostGIS-objektens interna lagring ändras eller när MJUK UPPGRADERING inte är möjlig. Bilagan Release Notes rapporterar för varje version om du behöver en dumpning/omladdning (HARD UPGRADE) för att uppgradera.
The dump/reload process is assisted by the postgis_restore script which takes care of skipping from the dump all definitions which belong to PostGIS (including old ones), allowing you to restore your schemas and data into a database with PostGIS installed without getting duplicate symbol errors or bringing forward deprecated objects.
Kompletterande instruktioner för Windows-användare finns på Windows Hard upgrade.
Förfarandet är som följer:
Skapa en dump i "anpassat format" av den databas du vill uppgradera (låt oss kalla den olddb) inklusive binära blobs (-b) och verbose (-v) utdata. Användaren kan vara ägaren av db, behöver inte vara postgres superkonto.
pg_dump -h localhost -p 5432 -U postgres -Fc -b -v -f "/somepath/olddb.backup" olddb
Gör en nyinstallation av PostGIS i en ny databas - vi kallar denna databas för newdb. Se Avsnitt 3.3.2, ”Spatial aktivering av databas utan att använda EXTENSION (avrådes)” och Avsnitt 3.3.1, ”Spatial aktivering av databas med hjälp av EXTENSION” för instruktioner om hur du gör detta.
De spatial_ref_sys-poster som finns i din dump kommer att återställas, men de kommer inte att åsidosätta befintliga poster i spatial_ref_sys. Detta är för att säkerställa att korrigeringar i den officiella uppsättningen kommer att spridas korrekt till återställda databaser. Om du av någon anledning verkligen vill ha dina egna åsidosättningar av standardposter, ladda bara inte spatial_ref_sys.sql-filen när du skapar den nya db.
Om din databas är riktigt gammal eller om du vet att du har använt funktioner som inte längre används i dina vyer och funktioner, kan du behöva läsa in legacy.sql för att alla dina funktioner och vyer etc. ska komma tillbaka på rätt sätt. Gör detta endast om det _verkligen_ behövs. Överväg att uppgradera dina vyer och funktioner innan du dumpar dem, om möjligt. De föråldrade funktionerna kan senare tas bort genom att läsa in uninstall_legacy.sql.
Återställ din säkerhetskopia till din nya newdb-databas med postgis_restore. Oväntade fel, om några, kommer att skrivas ut till standardfelströmmen av psql. Förvara en logg över dessa.
postgis_restore "/somepath/olddb.backup" | psql -h localhost -p 5432 -U postgres newdb 2> errors.txt
Fel kan uppstå i följande fall:
Några av dina vyer eller funktioner använder sig av föråldrade PostGIS-objekt. För att åtgärda detta kan du försöka läsa in legacy.sql-skriptet före återställningen eller så måste du återställa till en version av PostGIS som fortfarande innehåller dessa objekt och försöka migrera igen efter att ha portat din kod. Om legacy.sql fungerar för dig, glöm inte att fixa din kod så att den slutar använda föråldrade funktioner och ta bort dem genom att läsa in uninstall_legacy.sql.
Vissa anpassade poster i spatial_ref_sys i dumpfilen har ett ogiltigt SRID-värde. Giltiga SRID-värden är större än 0 och mindre än 999000. Värden i intervallet 999000.999999 är reserverade för internt bruk medan värden över 999999 inte kan användas alls. Alla dina anpassade poster med ogiltiga SRID kommer att behållas, med de > 999999 flyttade till det reserverade intervallet, men tabellen spatial_ref_sys skulle förlora en kontrollbegränsning som skyddar för att invariant ska hålla och eventuellt också dess primära nyckel (när flera ogiltiga SRIDS konverteras till samma reserverade SRID-värde).
För att åtgärda detta bör du kopiera din anpassade SRS till en SRID med ett giltigt värde (kanske i intervallet 910000..910999), konvertera alla dina tabeller till den nya srid (se UpdateGeometrySRID), ta bort den ogiltiga posten från spatial_ref_sys och konstruera om kontrollen (erna) med:
ALTER TABLE spatial_ref_sys ADD CONSTRAINT spatial_ref_sys_srid_check check (srid > 0 AND srid < 999000 );
ALTER TABLE spatial_ref_sys ADD PRIMARY KEY(srid));
Om du uppgraderar en gammal databas som innehåller fransk IGN-kartografi kommer du förmodligen att ha SRID: er utanför intervallet och du kommer att se, när du importerar din databas, problem som detta:
WARNING: SRID 310642222 converted to 999175 (in reserved zone)
I det här fallet kan du prova följande steg: först kasta ut IGN helt från sql som är resultatet av postgis_restore. Så, efter att ha kört :
postgis_restore "/somepath/olddb.backup" > olddb.sql
kör detta kommando :
grep -v IGNF olddb.sql > olddb-without-IGN.sql
Create your newdb, activate the required PostGIS extensions, and insert the French IGN spatial reference definitions using this script. After these operations, import your data:
psql -h localhost -p 5432 -U postgres -d newdb -f olddb-without-IGN.sql 2> errors.txt
Open Geospatial Consortium (OGC) har utvecklat Enkel åtkomst till funktioner (SFA) för att tillhandahålla en modell för geospatiala data. Den definierar den grundläggande spatiala typen av geometri, tillsammans med operationer som manipulerar och transformerar geometrivärden för att utföra spatiala analysuppgifter. PostGIS implementerar OGC Geometry-modellen som PostgreSQL-datatyperna geometri och geografi.
Geometry är en abstrakt typ. Geometry-värden tillhör en av dess konkreta subtyper som representerar olika typer och dimensioner av geometriska former. Dessa inkluderar atomtyperna Point, LineString, LinearRing och Polygon, samt samlingstyperna MultiPoint, MultiLineString, MultiPolygon och GeometryCollection. De Access till enkla funktioner - Del 1: Gemensam arkitektur v1.2.1 lägger till subtyper för strukturerna PolyhedralSurface, Triangle och TIN.
Geometry modellerar former i det 2-dimensionella kartesiska planet. Typerna PolyhedralSurface, Triangle och TIN kan också representera former i ett 3-dimensionellt rum. Formernas storlek och placering anges av deras koordinater. Varje koordinat har ett X- och Y-ordinatvärde som bestämmer dess läge i planet. Former konstrueras av punkter eller linjesegment, där punkter specificeras av en enda koordinat och linjesegment av två koordinater.
Coordinates may contain optional Z and M ordinate values. The Z ordinate is often used to represent elevation. The M ordinate contains a measure value, which may represent time or distance. If Z or M values are present in a geometry value, they must be defined for each point in the geometry. If a geometry has Z or M ordinates the coordinate dimension is 3D; if it has both Z and M the coordinate dimension is 4D. The coordinate dimension is at least 2, because every geometry has at least X and Y coordinates.
Geometrivärden associeras med ett spatialt referenssystem som anger det koordinatsystem i vilket det är inbäddat. Det spatiala referenssystemet identifieras av geometrins SRID-nummer. Enheterna för X- och Y-axlarna bestäms av det spatiala referenssystemet. I plana referenssystem representerar X- och Y-koordinaterna vanligtvis ost- och nordlig riktning, medan de i geodetiska system representerar longitud och latitud. SRID 0 representerar ett oändligt kartesiskt plan utan några enheter tilldelade dess axlar. Se Avsnitt 4.5, ”Spatiala referenssystem”.
The geometry dimension is a property of geometry types. Point types have dimension 0, linear types have dimension 1, polygonal types have dimension 2, and solid types have dimension 3. Collections have the dimension of the maximum element dimension.
Ett geometrivärde kan vara tomt. Tomma värden innehåller inga toppar (för atomära geometrityper) eller inga element (för samlingar).
En viktig egenskap hos geometrivärden är deras spatiala extent eller bounding box, som i OGC-modellen kallas envelope. Detta är den 2- eller 3-dimensionella box som omsluter koordinaterna för en geometri. Det är ett effektivt sätt att representera en geometris utbredning i koordinatrymden och att kontrollera om två geometrier interagerar.
The geometry model allows evaluating topological spatial relationships as described in Avsnitt 5.1.1, ”Dimensionsutvidgad 9-intersektionell modell”. To support this the concepts of interior, boundary and exterior are defined for each geometry type. Geometries are topologically closed, so they always contain their boundary. The boundary is a geometry of dimension one less than that of the geometry itself. For example, the boundary of a Polygon is its rings (LineStrings), the boundary of a LineString is its endpoints (Points), and the boundary of a Point is empty.
The OGC geometry model defines validity rules for each geometry type. These rules ensure that geometry values represents realistic situations (e.g. it is possible to specify a polygon with a hole lying outside its shell, but this makes no sense geometrically and is thus invalid). PostGIS also allows storing and manipulating invalid geometry values. This allows detecting and fixing them if needed. See Avsnitt 4.4, ”Validering av geometri”
En punkt är en 0-dimensionell geometri som representerar en enda plats i koordinatrymden.
POINT (1 2) POINT Z (1 2 3) POINT ZM (1 2 3 4)
En LineString är en 1-dimensionell linje som består av en sammanhängande sekvens av linjesegment. Varje linjesegment definieras av två punkter, där slutpunkten för ett segment utgör startpunkten för nästa segment. En OGC-valid LineString har antingen noll eller två eller flera punkter, men PostGIS tillåter även LineStrings med en enda punkt. LineStrings kan korsa sig själva (self-intersect). En LineString är sluten om start- och slutpunkterna är desamma. En LineString är enkel om den inte korsar sig själv.
LINESTRING (1 2, 3 4, 5 6)
En LinearRing är en LineString som är både sluten och enkel. Den första och den sista punkten måste vara lika och linjen får inte skära sig själv.
LINEARRING (0 0 0, 4 0 0, 4 4 0, 0 4 0, 0 0 0)
En polygon är en 2-dimensionell plan region som avgränsas av en yttre gräns (skalet) och noll eller flera inre gränser (hål). Varje gräns är en LinearRing.
POLYGON ((0 0 0, 4 0 0, 4 4 0, 0 4 0, 0 0 0), (1 1 0, 2 1 0, 2 2 0, 1 2 0, 1 1 0))
En MultiPoint är en samling punkter.
MULTIPOINT ( (0 0), (1 2) )
En MultiLineString är en samling LineStrings. En MultiLineString är sluten om vart och ett av dess element är slutet.
MULTILINESTRING ( (0 0, 1 1, 1 2), (2 3, 3 2, 5 4) )
A MultiPolygon is a collection of non-overlapping, non-adjacent Polygons. Polygons in the collection may touch only at a finite number of points. (Two polygons are adjacent if they share an edge. They touch if they share only points or edges on their boundaries). For more details on MultiPolygon validity, see Avsnitt 4.4, ”Validering av geometri”.
MULTIPOLYGON (((1 5, 5 5, 5 1, 1 1, 1 5)), ((6 5, 9 1, 6 1, 6 5)))
En GeometryCollection är en heterogen (blandad) samling av geometrier.
GEOMETRYCOLLECTION ( POINT(2 3), LINESTRING(2 3, 3 4))
En PolyhedralSurface är en sammanhängande samling av patcher eller facetter som delar vissa kanter. Varje patch är en plan polygon. Om polygonens koordinater har Z-ordinater är ytan 3-dimensionell.
POLYHEDRALSURFACE Z ( ((0 0 0, 0 0 1, 0 1 1, 0 1 0, 0 0 0)), ((0 0 0, 0 1 0, 1 1 0, 1 0 0, 0 0 0)), ((0 0 0, 1 0 0, 1 0 1, 0 0 1, 0 0 0)), ((1 1 0, 1 1 1, 1 0 1, 1 0 0, 1 1 0)), ((0 1 0, 0 1 1, 1 1 1, 1 1 0, 0 1 0)), ((0 0 1, 1 0 1, 1 1 1, 0 1 1, 0 0 1)) )
En triangel är en polygon som definieras av tre distinkta, icke-kollinjära hörn. Eftersom en triangel är en polygon anges den med fyra koordinater, där den första och den fjärde är lika.
TRIANGLE ((0 0, 0 9, 9 0, 0 0))
En TIN är en samling icke-överlappande trianglarsom representerar ett triangulerat oregelbundet nätverk.
TIN Z ( ((0 0 0, 0 0 1, 0 1 0, 0 0 0)), ((0 0 0, 0 1 0, 1 1 0, 0 0 0)) )
ISO/IEC 13249-3 ISO/IEC 13249-3 SQL Multimedia - Spatial (SQL/MM) utökar OGC SFA för att definiera Geometry-subtyper som innehåller kurvor med cirkelbågar. SQL/MM-typerna stöder 3DM-, 3DZ- och 4D-koordinater.
![]() | |
Alla jämförelser med flyttal i SQL-MM-implementationen utförs med en angiven tolerans, för närvarande 1E-8. |
CircularString är den grundläggande kurvtypen, ungefär som LineString i den linjära världen. Ett enkelt bågsegment specificeras av tre punkter: start- och slutpunkterna (första och tredje) samt någon annan punkt på bågen. För att specificera en sluten cirkel är start- och slutpunkterna desamma och mittpunkten är den motsatta punkten på cirkeldiametern (som är bågens mittpunkt). I en sekvens av bågar är slutpunkten för den föregående bågen startpunkten för nästa båge, precis som segmenten i en LineString. Detta innebär att en CircularString måste ha ett udda antal punkter som är större än 1.
CIRCULARSTRING(0 0, 1 1, 1 0) CIRCULARSTRING(0 0, 4 0, 4 4, 0 4, 0 0)
En CompoundCurve är en enda kontinuerlig kurva som kan innehålla både cirkelbågssegment och linjära segment. Det innebär att förutom att ha välformade komponenter måste slutpunkten för varje komponent (utom den sista) sammanfalla med startpunkten för följande komponent.
COMPOUNDCURVE( CIRCULARSTRING(0 0, 1 1, 1 0), (1 0, 0 1))
En CurvePolygon är som en polygon, med en yttre ring och noll eller flera inre ringar. Skillnaden är att en ring kan vara en CircularString eller CompoundCurve såväl som en LineString.
Från och med PostGIS 1.4 har PostGIS stöd för sammansatta kurvor i en kurvpolygon.
CURVEPOLYGON( CIRCULARSTRING(0 0, 4 0, 4 4, 0 4, 0 0), (1 1, 3 3, 3 1, 1 1) )
Exempel: En CurvePolygon med skalet definierat av en CompoundCurve som innehåller en CircularString och en LineString, och ett hål definierat av en CircularString
CURVEPOLYGON(
COMPOUNDCURVE( CIRCULARSTRING(0 0, 2 0, 2 1, 2 3, 4 3),
(4 3, 4 5, 1 4, 0 0)),
CIRCULARSTRING(1.7 1, 1.4 0.4, 1.6 0.4, 1.6 0.5, 1.7 1) )En MultiCurve är en samling kurvor som kan innehålla LineStrings, CircularStrings eller CompoundCurves.
MULTICURVE( (0 0, 5 5), CIRCULARSTRING(4 0, 4 4, 8 4))
En MultiSurface är en samling ytor, som kan vara (linjära) polygoner eller CurvePolygoner.
MULTISURFACE( CURVEPOLYGON( CIRCULARSTRING( 0 0, 4 0, 4 4, 0 4, 0 0), (1 1, 3 3, 3 1, 1 1)), ((10 10, 14 12, 11 10, 10 10), (11 11, 11.5 11, 11 11.5, 11 11)))
OGC SFA-specifikationen definierar två format för att representera geometriska värden för extern användning: Well-Known Text (WKT) och Well-Known Binary (WKB). Både WKT och WKB innehåller information om typen av objekt och de koordinater som definierar det.
Well-Known Text (WKT) tillhandahåller en standardiserad textuell representation av spatiala data. Exempel på WKT-representationer av spatiala objekt är:
PUNKT(0 0)
PUNKT Z (0 0 0)
PUNKT ZM (0 0 0 0)
PUNKT EMPTY
LINESTRING(0 0,1 1,1 2)
LINESTRING TOM
POLYGON((0 0,4 0,4 4,0 4,0 0),(1 1, 2 1, 2 2, 1 2,1 1))
MULTIPOINT((0 0),(1 2))
MULTIPOINT Z ((0 0 0),(1 2 3))
MULTIPOINT TOM
MULTILINESTRING((0 0,1 1,1 2),(2 3,3 2,5 4))
MULTIPOLYGON(((0 0,4 0,4 4,0 4,0 0),(1 1,2 1,2 2,1 2,1 1)), ((-1 -1,-1 -2,-2 -2,-2 -1,-1 -1 -1)))
GEOMETRYCOLLECTION(POINT(2 3), LINESTRING(2 3,3 4))
GEOMETRYUPPCOLLECTION TOM
In- och utdata för WKT tillhandahålls av funktionerna ST_AsText och ST_GeomFromText:
text WKT = geometry; geometry = ST_GeomFromText(text WKT, SRID);
For example, a statement to create and insert a spatial object from WKT with SRID 312 is:
INSERT INTO geotable ( geom, name )
VALUES ( ST_GeomFromText('POINT(-126.4 45.32)', 312), 'A Place');Well-Known Binary (WKB) tillhandahåller en portabel representation med full precision av spatiala data som binära data (matriser av bytes). Exempel på WKB-representationer av spatiala objekt är:
WKT: PUNKT(1 1)
WKB: 0101000000000000000000F03F000000000000F03
WKT: LINESTRING (2 2, 9 9)
WKB: 0102000000020000000000000000000040000000000000004000000000000022400000000000002240
In- och utdata för WKB tillhandahålls av funktionerna ST_AsBinary och ST_GeomFromWKB:
bytea WKB = ST_AsBinary(geometry); geometry = ST_GeomFromWKB(bytea WKB, SRID);
Ett villkor för att skapa och infoga ett spatialt objekt från WKB är t.ex:
INSERT INTO geotable ( geom, name )
VALUES ( ST_GeomFromWKB('\x0101000000000000000000f03f000000000000f03f', 312), 'A Place');PostGIS implementerar OGC Simple Features-modellen genom att definiera en PostgreSQL-datatyp som heter geometry. Den representerar alla undertyper av geometri med hjälp av en intern typkod (se GeometryType och ST_GeometryType). Detta gör det möjligt att modellera spatiala funktioner som rader i tabeller som definieras med en kolumn av typen geometri.
The geometry data type is opaque, which means that all access is done via invoking functions on geometry values. Functions allow creating geometry objects, accessing or updating all internal fields, and computing new geometry values. PostGIS supports all the functions specified in the OGC Simple feature access - Part 2: SQL option (SFS) specification, as well many others. See Kapitel 7, PostGIS-referens for the full list of functions.
![]() | |
PostGIS följer SFA-standarden genom att spatiala funktioner prefixeras med "ST_". Detta var tänkt att stå för "Spatial and Temporal", men den temporala delen av standarden utvecklades aldrig. Istället kan det tolkas som "Spatial Type". |
SFA-standarden anger att spatiala objekt ska innehålla en identifierare för spatialt referenssystem (Spatial Reference System identifier, SRID). SRID krävs när spatiala objekt skapas för införande i databasen (den kan vara 0 som standard). Se ST_SRID och Avsnitt 4.5, ”Spatiala referenssystem”
För att göra geometriska frågor effektiva definierar PostGIS olika typer av spatiala index och spatiala operatorer för att använda dem. Se Avsnitt 4.9, ”Spatiala index” och Avsnitt 5.2, ”Använda spatiala index” för mer information.
OGC SFA-specifikationerna stödde ursprungligen endast 2D-geometrier, och geometrins SRID ingår inte i inmatnings-/utdatarepresentationerna. OGC SFA-specifikationen 1.2.1 (som överensstämmer med ISO 19125-standarden) lägger till stöd för 3D (ZYZ) och uppmätta (XYM och XYZM) koordinater, men inkluderar fortfarande inte SRID-värdet.
På grund av dessa begränsningar har PostGIS definierat utökade EWKB- och EWKT-format. De ger stöd för koordinater i 3D (XYZ och XYM) och 4D (XYZM) och inkluderar SRID-information. Genom att inkludera all geometriinformation kan PostGIS använda EWKB som format för registrering (t.ex. i DUMP-filer).
EWKB och EWKT används för de "kanoniska formerna" för PostGIS dataobjekt. För indata är den kanoniska formen för binära data EWKB, och för textdata accepteras antingen EWKB eller EWKT. Detta gör det möjligt att skapa geometrivärden genom att kasta ett textvärde i antingen HEXEWKB eller EWKT till ett geometrivärde med hjälp av ::geometry. För utdata är den kanoniska formen för binära data EWKB och för text är den HEXEWKB (hex-kodad EWKB).
Till exempel skapar denna sats en geometri genom casting från ett EWKT-textvärde och matar ut den med den kanoniska formen av HEXEWKB:
SELECT 'SRID=4;POINT(0 0)'::geometry;
geometry ---------------------------------------------------- 01010000200400000000000000000000000000000000000000
PostGIS EWKT-utdata har några skillnader jämfört med OGC WKT:
För 3DZ-geometrier utelämnas Z-kvalificeraren:
OGC: PUNKT Z (1 2 3)
EWKT: PUNKT (1 2 3)
För 3DM-geometrier inkluderas M-kvalificeraren:
OGC: PUNKT M (1 2 3)
EWKT: POINTM (1 2 3)
För 4D-geometrier utelämnas ZM-kvalificeraren:
OGC: PUNKT ZM (1 2 3 4)
EWKT: PUNKT (1 2 3 4)
EWKT undviker överspecificering av dimensionalitet och de inkonsekvenser som kan uppstå med OGC/ISO-formatet, t.ex:
POINT ZM (1 1)
PUNKT ZM (1 1 1)
PUNKT (1 1 1 1 1)
![]() | |
PostGIS utökade format är för närvarande en superset av OGC:s format, så att varje giltig OGC WKB/WKT också är giltig EWKB/EWKT. Detta kan dock variera i framtiden, om OGC utökar ett format på ett sätt som strider mot PosGIS-definitionen. Därför SKA du INTE förlita dig på denna kompatibilitet! |
Exempel på EWKT-textrepresentation av spatiala objekt är:
PUNKT(0 0 0) -- XYZ
SRID=32632;POINT(0 0) -- XY med SRID
POINTM(0 0 0) -- XYM
PUNKT(0 0 0 0) -- XYZM
SRID=4326;MULTIPOINTM(0 0 0,1 2 1) -- XYM med SRID
MULTILINESTRING((0 0 0,1 1 0,1 2 1),(2 3 1,3 2 1,5 4 1))
POLYGON((0 0 0,4 0 0,4 4 0,0 4 0,0 0 0),(1 1 0,2 1 0,2 2 0,1 2 0,1 1 0))
MULTIPOLYGON(((0 0 0,4 0 0,4 4 0,0 4 0,0 0 0),(1 1 0,2 1 0,2 2 0,1 2 0,1 1 0)),((-1 -1 0,-1 -2 0,-2 -2 0,-2 -1 0,-1 -1 0)))
GEOMETRYCOLLECTIONM( PUNKTM(2 3 9), LINESTRINGM(2 3 4, 3 4 5) )
MULTICURVE( (0 0, 5 5), CIRCULARSTRING(4 0, 4 4, 8 4) )
POLYHEDRALSURFACE( ((0 0 0, 0 0 1, 0 1 1, 0 1 0, 0 0 0)), ((0 0 0, 0 1 0, 1 1 0, 1 0 0, 0 0 0)), ((0 0 0, 1 0 0, 1 0 1, 0 0 1, 0 0 0)), ((1 1 0, 1 1 1, 1 0 1, 1 0 0, 1 1 0)), ((0 1 0, 0 1 1, 1 1 1, 1 1 0, 0 1 0)), ((0 0 1, 1 0 1, 1 1 1, 0 1 1, 0 0 1)) )
TRIANGEL ((0 0, 0 10, 10 0, 0 0))
TIN( ((0 0 0, 0 0 1, 0 1 0, 0 0 0)), ((0 0 0, 0 1 0, 1 1 0, 0 0 0))) )
Inmatning och utdata med dessa format kan göras med hjälp av följande funktioner:
bytea EWKB = ST_AsEWKB(geometry); text EWKT = geometry; geometry = ST_GeomFromEWKB(bytea EWKB); geometry = ST_GeomFromEWKT(text EWKT);
Ett villkor för att skapa och infoga ett spatialt PostGIS-objekt med EWKT är t.ex:
INSERT INTO geotable ( geom, name )
VALUES ( ST_GeomFromEWKT('SRID=312;POINTM(-126.4 45.32 15)'), 'A Place' )Datatypen PostGIS geography ger inbyggt stöd för spatiala egenskaper som representeras av "geografiska" koordinater (ibland kallade "geodetiska" koordinater, eller "lat/lon", eller "lon/lat"). Geografiska koordinater är sfäriska koordinater uttryckta i vinkelenheter (grader).
Basen för PostGIS datatyp geometri är ett plan. Den kortaste vägen mellan två punkter på planet är en rät linje. Det innebär att funktioner på geometrier (ytor, avstånd, längder, skärningspunkter etc.) beräknas med hjälp av rätlinjiga vektorer och kartesisk matematik. Detta gör dem enklare att implementera och snabbare att utföra, men gör dem också felaktiga för data på jordens sfäroida yta.
PostGIS datatyp för geografi är baserad på en sfärisk modell. Den kortaste vägen mellan två punkter på sfären är en storcirkelbåge. Funktioner på geografier (områden, avstånd, längder, skärningspunkter etc.) beräknas med hjälp av bågar på sfären. Genom att ta hänsyn till världens sfäroida form ger funktionerna mer exakta resultat.
Eftersom den underliggande matematiken är mer komplicerad finns det färre funktioner definierade för geograftypen än för geometritypen. Med tiden, när nya algoritmer läggs till, kommer funktionerna för geograftypen att utökas. Som en nödlösning kan man konvertera fram och tillbaka mellan geometri- och geograftyperna.
Like the geometry data type, geography data is associated with a spatial reference system via a spatial reference system identifier (SRID). Any geodetic (long/lat based) spatial reference system defined in the spatial_ref_sys table can be used. You can add your own custom geodetic spatial reference system as described in Avsnitt 4.5.2, ”Användardefinierade spatiala referenssystem”.
För alla spatiala referenssystem är de enheter som returneras av mätfunktioner (t.ex. ST_Distance, ST_Length, ST_Perimeter, ST_Area) och för distansargumentet i ST_DWithin i meter.
Du kan skapa en tabell för att lagra geografiska data genom att använda SQL-satsen CREATE TABLE med en kolumn av typen geography. I följande exempel skapas en tabell med en geografikolumn som lagrar 2D LineStrings i det geodetiska koordinatsystemet WGS84 (SRID 4326):
CREATE TABLE global_points ( id SERIAL PRIMARY KEY, name VARCHAR(64), location geography(POINT, 4326) );
Geografitypen har stöd för två valfria typmodifierare:
modifieraren spatial type begränsar vilka typer av former och dimensioner som tillåts i kolumnen. Tillåtna värden för den spatiala typen är: POINT, LINESTRING, POLYGON, MULTIPOINT, MULTILINESTRING, MULTIPOLYGON, GEOMETRYCOLLECTION. Geografitypen stöder inte kurvor, TINS eller POLYHEDRALSURFACEs. Modifieraren stöder begränsningar av koordinatdimensionalitet genom att lägga till suffix: Z, M och ZM. En modifierare av typen "LINESTRINGM" tillåter t.ex. endast linestrings med tre dimensioner och behandlar den tredje dimensionen som ett mått. På samma sätt kräver "POINTZM" fyrdimensionella (XYZM) data.
sRID-modifieraren begränsar det spatiala referenssystemets SRID till ett visst nummer. Om SRID utelämnas är standardvärdet 4326 (WGS84 geodetic) och alla beräkningar utförs med WGS84.
Exempel på hur man skapar tabeller med geografikolumner:
Skapa en tabell med 2D POINT-geografi med standard SRID 4326 (WGS84 long/lat):
CREATE TABLE ptgeogwgs(gid serial PRIMARY KEY, geog geography(POINT));
Skapa en tabell med 2D POINT-geografi i NAD83 longlat:
CREATE TABLE ptgeognad83(gid serial PRIMARY KEY, geog geography(POINT, 4269));
Skapa en tabell med 3D (XYZ) POINTs och en explicit SRID på 4326:
CREATE TABLE ptzgeogwgs84(gid serial PRIMARY KEY, geog geography(POINTZ, 4326));
Skapa en tabell med 2D LINESTRING-geografi med standard SRID 4326:
CREATE TABLE lgeog(gid serial PRIMARY KEY, geog geography(LINESTRING));
Skapa en tabell med 2D POLYGON-geografi med SRID 4267 (NAD 1927 long lat):
CREATE TABLE lgeognad27(gid serial PRIMARY KEY, geog geography(POLYGON, 4267));
Geografiska fält registreras i systemvyn geography_columns. Du kan ställa en fråga till vyn geography_columns och se att tabellen finns med i listan:
SELECT * FROM geography_columns;
Att skapa ett spatialt index fungerar på samma sätt som för geometrikolumner. PostGIS kommer att notera att kolumntypen är GEOGRAPHY och skapa ett lämpligt sfärbaserat index istället för det vanliga plana indexet som används för GEOMETRY.
CREATE INDEX global_points_gix ON global_points USING GIST ( location );
Du kan infoga data i geograftabeller på samma sätt som i geometritabeller. Geometridata kommer att autokastas till geograftypen om den har SRID 4326. EWKT- och EWKB-formaten kan också användas för att ange geografiska värden.
INSERT INTO global_points (name, location) VALUES ('Town', 'SRID=4326;POINT(-110 30)');
INSERT INTO global_points (name, location) VALUES ('Forest', 'SRID=4326;POINT(-109 29)');
INSERT INTO global_points (name, location) VALUES ('London', 'SRID=4326;POINT(0 49)');
Alla geodetiska (lång/lat) spatiala referenssystem som förtecknas i tabellen spatial_ref_sys kan anges som ett geografiskt SRID. Icke-geodetiska koordinatsystem ger upphov till ett fel om de används.
A NAD83 longitude/latitude geography value:
SELECT 'SRID=4269;POINT(-123 34)'::geography;
geography ---------------------------------------------------- 0101000020AD1000000000000000C05EC00000000000004140
A NAD27 longitude/latitude geography value:
SELECT 'SRID=4267;POINT(-123 34)'::geography;
geography ---------------------------------------------------- 0101000020AB1000000000000000C05EC00000000000004140
NAD83 UTM zone meters fails because it is a meter-based planar projection.
SELECT 'SRID=26910;POINT(-123 34)'::geography;
ERROR: Only lon/lat coordinate systems are supported in geography.
Fråge- och mätfunktioner använder enheter i meter. Avståndsparametrar bör därför uttryckas i meter och returvärden bör förväntas i meter (eller kvadratmeter för områden).
This query finds rows within a 1000 km tolerance:
SELECT name FROM global_points WHERE ST_DWithin(location, 'SRID=4326;POINT(-110 29)'::geography, 1000000);
Du kan se geografins kraft i aktion genom att beräkna hur nära ett plan som flyger en cirkelrutt från Seattle till London (LINESTRING(-122,33 47,606, 0,0 51,5)) kommer Reykjavik (POINT(-21,96 64,15))(kartlägg rutten).
Geografitypen beräknar det kortaste verkliga avståndet på 122,235 km över sfären mellan Reykjavik och storcirkelflygvägen mellan Seattle och London.
SELECT ST_Distance('LINESTRING(-122.33 47.606,0.0 51.5)'::geography, 'POINT(-21.96 64.15)'::geography);st_distance ----------------- 122235.23815667
Geometritypen beräknar ett meningslöst kartesiskt avstånd mellan Reykjavik och den raka vägen från Seattle till London utritad på en platt världskarta. Den nominella enheten för resultatet är "grader", men resultatet motsvarar inte någon verklig vinkelskillnad mellan punkterna, så att kalla dem "grader" är felaktigt.
SELECT ST_Distance('LINESTRING(-122.33 47.606,0.0 51.5)'::geometry, 'POINT(-21.96 64.15)'::geometry);st_distance -------------------- 13.342271221453624
Med datatypen Geography kan du lagra data i koordinater för longitud/latitud, men till en kostnad: det finns färre funktioner definierade för GEOGRAPHY än för GEOMETRY; de funktioner som är definierade tar mer CPU-tid att utföra.
Den datatyp du väljer bör bestämmas av det förväntade arbetsområdet för den applikation du bygger. Kommer dina data att omfatta hela jordklotet eller ett stort kontinentalt område, eller är de lokala för en stat, ett län eller en kommun?
Om dina data finns i ett litet område kan det hända att du tycker att det är bäst att välja en lämplig projektion och använda GEOMETRY, med tanke på prestanda och tillgängliga funktioner.
Om dina data är globala eller täcker en kontinental region kanske du tycker att GEOGRAPHY gör att du kan bygga ett system utan att behöva oroa dig för projektionsdetaljer. Du lagrar dina data i longitud/latitud och använder de funktioner som har definierats i GEOGRAPHY.
Om du inte förstår projektioner, inte vill lära dig mer om dem och är beredd att acceptera de begränsningar i funktionalitet som finns i GEOGRAPHY, kan det vara lättare för dig att använda GEOGRAPHY än GEOMETRY. Läs in helt enkelt upp dina data som longitud/latitud och fortsätt därifrån.
Se Avsnitt 13.11, ”PostGIS matris för funktionsstöd” för en jämförelse mellan vad som stöds för Geography respektive Geometry. För en kort lista och beskrivning av Geography-funktioner, se Avsnitt 13.4, ”Stödfunktioner för geografi i PostGIS”
4.3.4.1. | Räknar du på sfären eller sfäroiden? |
By default, all distance and area calculations are done on the spheroid. You should find that the results of calculations in local areas match up well with local planar results in good local projections. Over larger areas, the spheroidal calculations will be more accurate than any calculation done on a projected plane. The difference is that the spheroid takes into account the curvature and non-spherical shape of the Earth, whereas planar calculations assume a flat surface. Alla geografifunktioner har möjlighet att använda en sfärberäkning genom att ställa in en sista boolesk parameter till "FALSE". Detta snabbar upp beräkningarna något, särskilt i fall där geometrierna är mycket enkla. | |
4.3.4.2. | Hur är det med datumlinjen och polerna? |
Alla beräkningar har ingen uppfattning om datumlinje eller poler, koordinaterna är sfäriska (longitud/latitud) så en form som korsar datumlinjen är, ur en beräkningssynpunkt, inte annorlunda än någon annan form. | |
4.3.4.3. | Vilken är den längsta båge du kan bearbeta? |
Vi använder storcirkelbågar som "interpoleringslinje" mellan två punkter. Det innebär att två punkter faktiskt sammanfogas på två olika sätt, beroende på vilken riktning du färdas längs storcirkeln. All vår kod förutsätter att punkterna sammanfogas av den *kortaste* av de två vägarna längs storcirkeln. Som en följd av detta kommer former som har bågar på mer än 180 grader inte att modelleras korrekt. | |
4.3.4.4. | Varför är det så långsamt att beräkna området Europa / Ryssland / infoga stor geografisk region här ? |
Eftersom polygonen är så jäkla stor! Stora områden är dåliga av två skäl: deras gränser är enorma, så indexet tenderar att dra funktionen oavsett vilken fråga du kör; antalet toppar är enormt, och tester (avstånd, inneslutning) måste korsa topplistan minst en gång och ibland N gånger (med N som antalet toppar i den andra kandidatfunktionen). Precis som med GEOMETRY rekommenderar vi att du, när du har mycket stora polygoner men gör sökningar i små områden, "denormaliserar" dina geometriska data i mindre bitar så att indexet effektivt kan göra underfrågor på delar av objektet och så att sökningarna inte behöver ta fram hela objektet varje gång. Vänligen se ST_Subdivide funktionsdokumentation. Bara för att du *kan* lagra hela Europa i en polygon betyder det inte att du *bör* göra det. |
PostGIS är förenligt med Open Geospatial Consortiums (OGC) specifikation för enkla funktioner. Denna standard definierar begreppen enkel och giltig geometri. Dessa definitioner gör det möjligt för geometrimodellen Simple Features att representera spatiala objekt på ett konsekvent och otvetydigt sätt som stöder effektiva beräkningar. (Obs: OGC SF och SQL/MM har samma definitioner för enkel och giltig)
En enkel geometri är en geometri som inte har några avvikande geometriska punkter, t.ex. självskärning eller självtangentiering.
En POINT är i sig själv enkel som ett 0-dimensionellt geometriobjekt.
MULTIPOINTsär enkla om inte två koordinater(POINTs)är lika (har identiska koordinatvärden).
En LINESTRING är enkel om den inte passerar genom samma punkt två gånger, med undantag för ändpunkterna. Om ändpunkterna på en enkel LineString är identiska kallas den sluten och kallas för en Linear Ring.
Use ST_IsSimple to classify linear geometries. Each labeled result below is returned only when the function agrees with the stated classification; example (c) also verifies that the simple LineString is closed.
WITH cases(label, geom) AS (VALUES
('a', 'LINESTRING (10 190, 140 130, 70 80, 190 10)'::geometry),
('b', 'LINESTRING (10 190, 130 40, 170 160, 10 10)'::geometry),
('c', 'LINESTRING (90 190, 120 190, 130 140, 190 50, 70 10, 10 70, 10 150, 90 190)'::geometry),
('d', 'LINESTRING (90 190, 120 190, 50 60, 130 10, 190 50, 160 90, 10 150, 90 190)'::geometry)
)
SELECT
(SELECT geom FROM cases WHERE label = 'a' AND ST_IsSimple(geom))
AS "input_(a) simple",
(SELECT geom FROM cases WHERE label = 'b' AND NOT ST_IsSimple(geom))
AS "input_(b) not simple",
(SELECT geom FROM cases
WHERE label = 'c' AND ST_IsSimple(geom) AND ST_IsClosed(geom))
AS "input_(c) simple, closed",
(SELECT geom FROM cases WHERE label = 'd' AND NOT ST_IsSimple(geom))
AS "input_(d) not simple";En MULTILINESTRING är enkel endast om alla dess element är enkla och den enda skärningen mellan två element sker i punkter som ligger på båda elementens gränser.
The next example applies the same classification to the three MultiLineStrings. In (f) the component lines meet only at a shared endpoint, while in (g) they cross in their interiors.
WITH cases(label, geom) AS (VALUES
('e', 'MULTILINESTRING ((30 190, 60 60, 170 10), (100 190, 180 150, 160 70))'::geometry),
('f', 'MULTILINESTRING ((30 190, 60 60, 170 10), (30 190, 180 150, 160 70))'::geometry),
('g', 'MULTILINESTRING ((30 190, 60 60, 170 10), (100 190, 180 150, 80 10))'::geometry)
)
SELECT
(SELECT geom FROM cases WHERE label = 'e' AND ST_IsSimple(geom))
AS "input_(e) simple",
(SELECT geom FROM cases WHERE label = 'f' AND ST_IsSimple(geom))
AS "input_(f) simple",
(SELECT geom FROM cases WHERE label = 'g' AND NOT ST_IsSimple(geom))
AS "input_(g) not simple";POLYGONERbildas av linjära ringar, så giltig polygonal geometri är alltid enkel.
Generellt kräver inte PostGIS-funktioner att geometriska argument ska vara enkla. Enkelhet används främst som en grund för att definiera geometrisk validitet. Det är också ett krav för vissa typer av spatiala datamodeller (t.ex. tillåter linjära nätverk ofta inte linjer som korsar varandra). Multipunkts- och linjärgeometri kan göras enkel med hjälp av ST_UnaryUnion.
Geometrisk validitet gäller främst för 2-dimensionella geometrier(POLYGONERoch MULTIPOLYGONER). Validiteten definieras av regler som gör att polygonal geometri kan modellera plana områden på ett otvetydigt sätt.
En POLYGON är giltig om:
polygonens begränsningsringar (den yttre skalringen och de inre hålringarna) är enkla (korsar inte varandra och berör inte varandra). På grund av detta kan en polygon inte ha snittlinjer, spikar eller öglor. Detta innebär att polygonhål måste representeras som inre ringar, snarare än genom att den yttre ringen självberör (ett s.k. "inverterat hål").
gränsringarna korsar inte varandra
begränsningsringar kan beröra varandra i punkter men endast som en tangent (dvs. inte i en linje)
inre ringar är inneslutna i den yttre ringen
polygonens inre är enkelt sammanhängande (dvs. ringarna får inte beröra varandra på ett sätt som delar upp polygonen i mer än en del)
Consecutive repeated points in a polygon boundary ring do not make the ring non-simple. Under the SFS curve model, a curve is interpreted by a continuous parameterization; consecutive equal coordinates are topologically indistinguishable from a single vertex. PostGIS therefore treats them as redundant vertices, so they do not make an otherwise valid polygon invalid.
The following examples use ST_IsValid to check the validity rules. Each labeled geometry is returned only if its computed validity agrees with the label.
WITH cases(label, geom) AS (VALUES
('h', 'POLYGON ((10 140, 90 190, 130 170, 190 60, 160 10, 50 20, 10 140),
(50 100, 70 80, 110 100, 110 140, 50 100))'::geometry),
('i', 'POLYGON ((10 140, 90 190, 130 170, 190 60, 160 10, 50 20, 10 140),
(190 60, 140 40, 110 60, 120 90, 190 60))'::geometry)
)
SELECT
(SELECT geom FROM cases WHERE label = 'h' AND ST_IsValid(geom))
AS "input_(h) valid",
(SELECT geom FROM cases WHERE label = 'i' AND ST_IsValid(geom))
AS "input_(i) valid, tangent hole";Examples (j-m) are invalid. They show, respectively, a disconnected interior, crossing rings, a cut line, and a hole outside the shell. The invalidity reason is checked with ST_IsValidReason. The disconnected interior in (j) can instead be represented as a valid MULTIPOLYGON.
WITH cases(label, geom, reason_pattern) AS (VALUES
('(j) disconnected interior',
'POLYGON ((10 140, 90 190, 130 170, 190 60, 160 10, 50 20, 10 140),
(130 170, 10 140, 50 120, 110 110, 130 170))'::geometry,
'Interior is disconnected%'),
('(k) crossing rings',
'POLYGON ((10 140, 90 190, 130 170, 190 60, 160 10, 50 20, 10 140),
(90 189, 10 139, 80 110, 110 130, 90 189))'::geometry,
'Self-intersection%'),
('(l) cut line',
'POLYGON ((10 100, 60 140, 60 190, 60 140, 130 170,
190 60, 160 10, 50 20, 10 100))'::geometry,
'Ring Self-intersection%'),
('(m) hole outside shell',
'POLYGON ((10 40, 10 100, 130 130, 190 80, 140 20, 50 10, 10 40),
(81 143, 103 143, 112 162, 107 175, 89 183, 71 169, 81 143))'::geometry,
'Hole lies outside shell%')
)
SELECT label, geom
FROM cases
WHERE NOT ST_IsValid(geom)
AND ST_IsValidReason(geom) LIKE reason_pattern
ORDER BY label;label | geom -------------------------+---------------------------------------------------------------------------------------------------------------------------------------- (j) disconnected interior | POLYGON((10 140,90 190,130 170,190 60,160 10,50 20,10 140),(130 170,10 140,50 120,110 110,130 170)) (k) crossing rings | POLYGON((10 140,90 190,130 170,190 60,160 10,50 20,10 140),(90 189,10 139,80 110,110 130,90 189)) (l) cut line | POLYGON((10 100,60 140,60 190,60 140,130 170,190 60,160 10,50 20,10 100)) (m) hole outside shell | POLYGON((10 40,10 100,130 130,190 80,140 20,50 10,10 40),(81 143,103 143,112 162,107 175,89 183,71 169,81 143))
En MULTIPOLYGON är giltig om:
dess element POLYGONERär giltiga
elementen inte överlappar varandra (dvs. deras insidor får inte skära varandra)
elementen berör varandra endast i punkter (dvs. inte längs en linje)
The next example checks the MultiPolygon rules. In (n) the polygons touch at only one point. In (o) they share an edge, and in (p) their interiors overlap.
WITH cases(label, geom, valid, reason_pattern) AS (VALUES
('(n) point touch',
'MULTIPOLYGON (((10 40, 29 118, 100 75, 180 88, 140 30, 70 10, 10 40)),
((50 170, 100 190, 160 180, 180 140, 180 90, 120 120,
30 120, 50 170)))'::geometry,
true, NULL),
('(o) shared edge',
'MULTIPOLYGON (((10 40, 30 120, 120 120, 180 88, 140 30, 70 10, 10 40)),
((50 170, 100 190, 160 180, 180 140, 180 90, 120 120,
30 120, 50 170)))'::geometry,
false, 'Self-intersection%'),
('(p) overlap',
'MULTIPOLYGON (((10 40, 42 93, 130 150, 180 86, 140 30, 70 10, 10 40)),
((50 170, 100 190, 138 182, 149 156, 146 137, 100 100,
58 140, 50 170)))'::geometry,
false, 'Self-intersection%')
)
SELECT label, geom
FROM cases
WHERE ST_IsValid(geom) = valid
AND (valid OR ST_IsValidReason(geom) LIKE reason_pattern)
ORDER BY label;label | geom ------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------- (n) point touch | MULTIPOLYGON(((10 40,29 118,100 75,180 88,140 30,70 10,10 40)),((50 170,100 190,160 180,180 140,180 90,120 120,30 120,50 170))) (o) shared edge | MULTIPOLYGON(((10 40,30 120,120 120,180 88,140 30,70 10,10 40)),((50 170,100 190,160 180,180 140,180 90,120 120,30 120,50 170))) (p) overlap | MULTIPOLYGON(((10 40,42 93,130 150,180 86,140 30,70 10,10 40)),((50 170,100 190,138 182,149 156,146 137,100 100,58 140,50 170)))
Dessa regler innebär att giltig polygonal geometri också är enkel..
För linjär geometri är den enda giltighetsregeln att LINESTRINGsmåste ha minst två punkter och ha en längd som inte är noll (eller motsvarande, ha minst två distinkta punkter.) Observera att icke-enkla (självskärande) linjer är giltiga.
SELECT
ST_IsValid('LINESTRING(0 0,1 1)') AS len_nonzero,
ST_IsValid('LINESTRING(0 0,0 0,0 0)') AS len_zero,
ST_IsValid('LINESTRING(10 10,150 150,180 50,20 130)') AS self_int;len_nonzero | len_zero | self_int -------------+----------+---------- t | f | t
POINT- och MULTIPOINT-geometrierna har inga giltighetsregler.
PostGIS tillåter skapande och lagring av både giltig och ogiltig geometri. Detta gör att ogiltig geometri kan upptäckas och flaggas eller fixas. Det finns också situationer där OGC:s giltighetsregler är strängare än önskat (exempel på detta är linestrings med noll längd och polygoner med inverterade hål)
Många av de funktioner som PostGIS tillhandahåller förutsätter att geometriargumenten är giltiga. Det är till exempel inte meningsfullt att beräkna arean av en polygon som har ett hål definierat utanför polygonen, eller att konstruera en polygon från en icke-enkel begränsningslinje. Genom att anta giltiga geometriska indata kan funktioner arbeta mer effektivt, eftersom de inte behöver kontrollera att de är topologiskt korrekta. (Noterbara undantag är att nollängdslinjer och polygoner med inversioner i allmänhet hanteras korrekt) Dessutom producerar de flesta PostGIS-funktioner giltiga geometriska utdata om indata är giltiga. Detta gör att PostGIS-funktioner kan kedjas ihop på ett säkert sätt.
Om du stöter på oväntade felmeddelanden när du anropar PostGIS-funktioner (t.ex. "GEOS Intersection() kastade ett fel!") bör du först bekräfta att funktionsargumenten är giltiga. Om de inte är det bör du överväga att använda någon av nedanstående tekniker för att säkerställa att de data du bearbetar är giltiga.
![]() | |
Om en funktion rapporterar ett fel med giltiga indata kan du ha hittat ett fel i antingen PostGIS eller ett av de bibliotek som används, och du bör rapportera detta till PostGIS-projektet. Detsamma gäller om en PostGIS-funktion returnerar en ogiltig geometri för giltig indata. |
För att testa om en geometri är giltig kan du använda funktionen ST_IsValid:
SELECT ST_IsValid('POLYGON ((20 180,180 180,180 20,20 20,20 180))');t
Information om arten av och platsen för en geometrisk invaliditet tillhandahålls av funktionen ST_IsValidDetail:
SELECT valid, reason,location AS location
FROM ST_IsValidDetail('POLYGON ((20 20,120 190,50 190,170 50,20 20))') AS t;valid | reason | location -------+-------------------+--------------------------------------------- f | Self-intersection | POINT(91.51162790697674 141.56976744186048)
I vissa situationer är det önskvärt att korrigera ogiltig geometri automatiskt. Använd funktionen ST_MakeValid för att göra detta.(ST_MakeValid är ett exempel på en spatial funktion som tillåter ogiltiga indata!)
Som standard kontrollerar PostGIS inte giltigheten vid laddning av geometri, eftersom giltighetstestning kan ta mycket CPU-tid för komplexa geometrier. Om du inte litar på dina datakällor kan du tvinga fram en giltighetskontroll på dina tabeller genom att lägga till en check constraint:
ALTER TABLE mytable ADD CONSTRAINT geometry_valid_check CHECK (ST_IsValid(geom));
Ett spatialt referenssystem (SRS) (även kallat koordinatreferenssystem (CRS)) definierar hur geometri refereras till platser på jordens yta. Det finns tre typer av SRS:
En geodetisk SRS använder vinkelkoordinater (longitud och latitud) som kartläggs direkt på jordytan.
En projicerad SRS använder en matematisk projektionstransformation för att "platta till" ytan på den sfäroida jorden till ett plan. Den tilldelar platskoordinater på ett sätt som gör det möjligt att direkt mäta storheter som avstånd, yta och vinkel. Koordinatsystemet är kartesiskt, vilket innebär att det har en definierad ursprungspunkt och två vinkelräta axlar (vanligtvis orienterade mot norr och öster). Varje projicerad SRS använder en angiven längdenhet (vanligtvis meter eller fot). En projicerad SRS kan vara begränsad i sitt tillämpningsområde för att undvika distorsion och passa inom de definierade koordinatgränserna.
Ett lokalt SRS är ett kartesiskt koordinatsystem som inte är refererat till jordytan. I PostGIS specificeras detta med ett SRID-värde på 0.
Det finns många olika spatiala referenssystem i bruk. Vanliga SRS är standardiserade i European Petroleum Survey Group EPSG-databasen. För enkelhetens skull hänvisar PostGIS (och många andra spatiala system) till SRS-definitioner med hjälp av en heltalsidentifierare som kallas SRID.
En geometri är associerad med ett spatialt referenssystem genom sitt SRID-värde, som nås via ST_SRID. SRID för en geometri kan tilldelas med hjälp av ST_SetSRID. Vissa geometry constructor-funktioner gör det möjligt att ange en SRID (t.ex. ST_Point och ST_MakeEnvelope). EWKT-formatet stöder SRID med prefixet SRID=n;..
Spatiala funktioner som bearbetar par av geometrier (t.ex. överlagrings- och relationsfunktioner ) kräver att de ingående geometrierna finns i samma spatiala referenssystem (har samma SRID). Geometridata kan omvandlas till ett annat spatialt referenssystem med hjälp av ST_Transform och ST_TransformPipeline. Geometri som returneras från funktioner har samma SRS som indatageometrierna.
Tabellen SPATIAL_REF_SYS som används av PostGIS är en OGC-kompatibel databastabell som definierar de tillgängliga spatiala referenssystemen. Den innehåller de numeriska SRID:erna och textbeskrivningarna av koordinatsystemen.
Definitionen av tabellen spatial_ref_sys är:
CREATE TABLE spatial_ref_sys ( srid INTEGER NOT NULL PRIMARY KEY, auth_name VARCHAR(256), auth_srid INTEGER, srtext VARCHAR(2048), proj4text VARCHAR(2048) )
Kolumnerna är..:
sridEn heltalskod som unikt identifierar det spatiala referenssystemet (SRS) i databasen.
auth_nameNamnet på den standard eller det standardiseringsorgan som åberopas för detta referenssystem. Exempelvis är "EPSG" ett giltigt auth_name.
auth_sridID för det spatiala referenssystemet enligt definitionen av den myndighet som anges i auth_name. När det gäller EPSG är detta EPSG-koden.
srtextRepresentationen av det spatiala referenssystemet i Well-Known Text. Ett exempel på en WKT SRS-representation är:
PROJCS["NAD83 / UTM Zone 10N",
GEOGCS["NAD83",
DATUM["North_American_Datum_1983",
SPHEROID["GRS 1980", 6378137, 298.257222101]
],
PRIMEM["Greenwich", 0],
UNIT["degree", 0.0174532925199433]
],
PROJECTION["Transverse_Mercator"],
PARAMETER["latitude_of_origin", 0],
PARAMETER["central_meridian", -123],
PARAMETER["scale_factor", 0.9996],
PARAMETER["false_easting", 500000],
PARAMETER["false_northing", 0],
UNIT["metre", 1]
]För en diskussion om SRS WKT, se OGC-standarden Well-known text representation of coordinate reference systems.
proj4textPostGIS använder PROJ-biblioteket för att tillhandahålla funktioner för koordinattransformation. Kolumnen proj4text innehåller PROJ-koordinatdefinitionssträngen för en viss SRID. Till exempel:
+proj=utm +zone=10 +ellps=clrk66 +datum=NAD27 +units=m
Mer information finns på PROJ-webbplatsen. Filen spatial_ref_sys.sql innehåller både srtext- och proj4text-definitioner för alla EPSG-projektioner.
Vid hämtning av definitioner av spatiala referenssystem för användning i transformationer använder PostGIS följande strategi:
Om auth_name och auth_srid finns (icke-NULL) används PROJ SRS baserat på dessa poster (om en sådan finns).
Om srtext finns kan du om möjligt skapa en SRS med hjälp av den.
Om proj4text finns kan du om möjligt skapa en SRS med hjälp av den.
Tabellen PostGIS spatial_ref_sys innehåller över 3000 av de vanligaste definitionerna av spatiala referenssystem som hanteras av PROJ-projektionsbiblioteket. Men det finns många koordinatsystem som den inte innehåller. Du kan lägga till SRS-definitioner i tabellen om du har den information som krävs om det spatiala referenssystemet. Eller så kan du definiera ditt eget spatiala referenssystem om du är bekant med PROJ constructs. Tänk på att de flesta spatiala referenssystem är regionala och inte har någon betydelse när de används utanför de gränser som de är avsedda för.
En resurs för att hitta spatiala referenssystem som inte definieras i kärnuppsättningen är http://spatialreference.org/
Some commonly used spatial reference systems are: 4326 - WGS 84 Long Lat, 4269 - NAD 83 Long Lat, 3395 - WGS 84 World Mercator, 2163 - US National Atlas Equal Area, and the 60 WGS84 UTM zones. UTM zones are one of the most ideal for measurement, but only cover 6-degree regions. For WGS84 longitude/latitude data, the UTM zone is least(floor((longitude + 180) / 6) + 1, 60); the EPSG code is 32600 + zone in the northern hemisphere or 32700 + zone in the southern hemisphere.
Amerikanska delstater använder spatiala referenssystem i State Plane (meter- eller fotbaserade) - vanligtvis finns ett eller två per delstat. De flesta av de meterbaserade finns i kärnuppsättningen, men många av de fotbaserade eller ESRI-skapade måste kopieras från spatialreference.org.
Du kan även definiera koordinatsystem som inte är jordbaserade, t.ex. Mars 2000 Mars koordinatsystem är inte planar (det är i grader sfäroidalt), men du kan använda det med geograftypen för att få längd- och avståndsmätningar i meter i stället för grader.
Här är ett exempel på laddning av ett anpassat koordinatsystem med hjälp av en icke tilldelad SRID och PROJ-definitionen för en US-centrisk Lambert Conformal-projektion:
INSERT INTO spatial_ref_sys (srid, proj4text) VALUES ( 990000, '+proj=lcc +lon_0=-95 +lat_0=25 +lat_1=25 +lat_2=25 +x_0=0 +y_0=0 +datum=WGS84 +units=m +no_defs' );
Du kan skapa en tabell för att lagra geometridata genom att använda SQL-satsen CREATE TABLE med en kolumn av typen geometry. I följande exempel skapas en tabell med en geometrikolumn som lagrar 2D (XY) LineStrings i BC-Albers koordinatsystem (SRID 3005):
CREATE TABLE roads ( id SERIAL PRIMARY KEY, name VARCHAR(64), geom geometry(LINESTRING, 3005) );
Geometritypen har stöd för två valfria typmodifierare:
Modifieraren för spatial typ begränsar vilken typ av former och dimensioner som tillåts i kolumnen. Värdet kan vara vilken som helst av de undertyper av geometri som stöds (t.ex. POINT, LINESTRING, POLYGON, MULTIPOINT, MULTILINESTRING, MULTIPOLYGON, GEOMETRYCOLLECTION etc.). Modifieraren stöder begränsningar av koordinatdimensionalitet genom att lägga till suffix: Z, M och ZM. En modifierare av typen "LINESTRINGM" tillåter t.ex. endast linestrings med tre dimensioner och behandlar den tredje dimensionen som ett mått. På samma sätt kräver "POINTZM" fyrdimensionella (XYZM) data.
sRID-modifieraren begränsar det spatiala referenssystemets SRID till ett visst nummer. Om den utelämnas är SRID standardvärdet 0.
Exempel på hur man skapar tabeller med geometrikolumner:
Skapa en tabell som innehåller alla typer av geometrier med standard-SRID:
CREATE TABLE geoms(gid serial PRIMARY KEY, geom geometry);
Skapa en tabell med 2D POINT-geometri med standard-SRID:
CREATE TABLE pts(gid serial PRIMARY KEY, geom geometry(POINT));
Skapa en tabell med 3D (XYZ) POINTs och en explicit SRID på 3005:
CREATE TABLE pts(gid serial PRIMARY KEY, geom geometry(POINTZ, 3005));
Skapa en tabell med 4D (XYZM) LINESTRING-geometri med standard SRID:
CREATE TABLE lines(gid serial PRIMARY KEY, geom geometry(LINESTRINGZM));
Skapa en tabell med 2D POLYGON-geometri med SRID 4267 (NAD 1927 long lat):
CREATE TABLE polys(gid serial PRIMARY KEY, geom geometry(POLYGON, 4267));
Det är möjligt att ha mer än en geometrikolumn i en tabell. Detta kan anges när tabellen skapas, eller så kan en kolumn läggas till med SQL-satsen ALTER TABLE. I detta exempel läggs en kolumn till som kan innehålla 3D LineStrings:
ALTER TABLE roads ADD COLUMN geom2 geometry(LINESTRINGZ, 4326);
OGC:s Simple Features Specification for SQL definierar metadatatabellen GEOMETRY_COLUMNS för att beskriva geometritabellens struktur. I PostGIS är geometry_columns en vy som läser från databassystemets katalogtabeller. Detta säkerställer att den spatiala metadatainformationen alltid överensstämmer med de tabeller och vyer som för närvarande definieras. Vyn har följande struktur:
\d geometry_columns
View "public.geometry_columns"
Column | Type | Modifiers
-------------------+------------------------+-----------
f_table_catalog | character varying(256) |
f_table_schema | character varying(256) |
f_table_name | character varying(256) |
f_geometry_column | character varying(256) |
coord_dimension | integer |
srid | integer |
type | character varying(30) |Kolumnerna är..:
f_table_catalog, f_table_schema, f_table_nameDet fullständigt kvalificerade namnet på funktionstabellen som innehåller geometrikolumnen. Det finns ingen PostgreSQL-analog av "katalog" så den kolumnen lämnas tom. För "schema" används PostgreSQL-schemanamnet(offentligt är standard).
f_geometry_columnNamnet på geometrikolumnen i feature-tabellen.
coord_dimensionThe coordinate dimension (2, 3 or 4) of the column. The coordinate dimension is at least 2, representing X and Y coordinates.
sridID för det spatiala referenssystem som används för koordinatgeometrin i denna tabell. Det är en främmande nyckelreferens till tabellen spatial_ref_sys (se Avsnitt 4.5.1, ”Tabellen SPATIAL_REF_SYS”).
typeTypen av det spatiala objektet. För att begränsa den spatiala kolumnen till en enda typ, använd en av följande: POINT, LINESTRING, POLYGON, MULTIPOINT, MULTILINESTRING, MULTIPOLYGON, GEOMETRYCOLLECTION eller motsvarande XYM-versioner POINTM, LINESTRINGM, POLYGONM, MULTIPOINTM, MULTILINESTRINGM, MULTIPOLYGONM, GEOMETRYCOLLECTIONM. För heterogena samlingar (av blandad typ) kan du använda "GEOMETRY" som typ.
Två av de fall där du kan behöva detta är vid SQL Views och bulkinsättningar. För bulkinsättningar kan du korrigera registreringen i geometry_columns-tabellen genom att begränsa kolumnen eller göra en alter table. För vyer kan du exponera med hjälp av en CAST-operation. Observera att om din kolumn är typmodbaserad kommer skapandeprocessen att registrera den korrekt, så du behöver inte göra någonting. Även vyer som inte har någon spatial funktion applicerad på geometrin kommer att registreras på samma sätt som den underliggande tabellgeometrikolumnen.
For example, suppose you have a view created like this.
CREATE VIEW public.vwmytablemercator AS SELECT gid, ST_Transform(geom, 3395) As geom, f_name FROM public.mytable;
To register the geometry column correctly, cast the transformed geometry.
DROP VIEW public.vwmytablemercator;
CREATE VIEW public.vwmytablemercator AS
SELECT gid, ST_Transform(geom, 3395)::geometry(Geometry, 3395) As geom, f_name
FROM public.mytable;If the geometry type is known to be a 2D Polygon, specify it in the cast.
DROP VIEW public.vwmytablemercator;
CREATE VIEW public.vwmytablemercator AS
SELECT gid, ST_Transform(geom, 3395)::geometry(Polygon, 3395) As geom, f_name
FROM public.mytable;For a derivative table created by a bulk insert, create the table first.
SELECT poi.gid, poi.geom, citybounds.city_name INTO myschema.my_special_pois FROM poi INNER JOIN citybounds ON ST_Intersects(citybounds.geom, poi.geom);
Create a 2D spatial index on the new table.
CREATE INDEX idx_myschema_myspecialpois_geom_gist ON myschema.my_special_pois USING gist(geom);
If the points are 3D or measured, an n-D index may be more appropriate.
CREATE INDEX my_special_pois_geom_gist_nd ON my_special_pois USING gist(geom gist_geometry_ops_nd);
Manually register the new table's geometry column in geometry_columns. This also changes the underlying table structure to make the column typmod-based.
SELECT Populate_Geometry_Columns('myschema.my_special_pois'::regclass);To retain constraint-based definition behavior, such as for inherited tables where all children do not have the same type and SRID, set the optional use_typmod argument to false.
SELECT Populate_Geometry_Columns('myschema.my_special_pois'::regclass, false);Although the old constraint-based method is still supported, direct pass-through view columns register correctly in geometry_columns for both typmod-based and constraint-based source columns. In this example we define a column using typmod and another using constraints.
CREATE TABLE pois_ny(gid SERIAL PRIMARY KEY, poi_name text, cat text, geom geometry(POINT, 4326));
SELECT AddGeometryColumn('pois_ny', 'geom_2160', 2160, 'POINT', 2, false);If we run \d pois_ny in psql, we observe they are defined differently -- one is typmod, one is constraint.
\d pois_ny
Table "public.pois_ny"
Column | Type | Modifiers
-----------+-----------------------+------------------------------------------------------
gid | integer | not null default nextval('pois_ny_gid_seq'::regclass)
poi_name | text |
cat | character varying(20) |
geom | geometry(Point,4326) |
geom_2160 | geometry |
Indexes:
"pois_ny_pkey" PRIMARY KEY, btree (gid)
Check constraints:
"enforce_dims_geom_2160" CHECK (st_ndims(geom_2160) = 2)
"enforce_geotype_geom_2160" CHECK (geometrytype(geom_2160) = 'POINT'::text
OR geom_2160 IS NULL)
"enforce_srid_geom_2160" CHECK (st_srid(geom_2160) = 2160)I geometry_columns registreras de båda korrekt
SELECT f_table_name, f_geometry_column, srid, type FROM geometry_columns WHERE f_table_name = 'pois_ny';
f_table_name | f_geometry_column | srid | type -------------+-------------------+------+------- pois_ny | geom | 4326 | POINT pois_ny | geom_2160 | 2160 | POINT
Men - om vi skulle skapa en vy så här
CREATE VIEW vw_pois_ny_parks AS
SELECT *
FROM pois_ny
WHERE cat='park';
SELECT f_table_name, f_geometry_column, srid, type
FROM geometry_columns
WHERE f_table_name = 'vw_pois_ny_parks';Both the typmod based geom view column and the direct constraint based view column register correctly.
f_table_name | f_geometry_column | srid | type ------------------+-------------------+------+---------- vw_pois_ny_parks | geom | 4326 | POINT vw_pois_ny_parks | geom_2160 | 2160 | POINT
If the view applies a spatial function to the geometry, such as ST_Transform, you still need to cast the transformed column explicitly so the view can expose the correct type and SRID:
DROP VIEW vw_pois_ny_parks;
CREATE VIEW vw_pois_ny_parks AS
SELECT gid, poi_name, cat,
geom,
ST_Transform(geom, 2160)::geometry(POINT, 2160) As geom_2160
FROM pois_ny
WHERE cat = 'park';
SELECT f_table_name, f_geometry_column, srid, type
FROM geometry_columns
WHERE f_table_name = 'vw_pois_ny_parks';f_table_name | f_geometry_column | srid | type ------------------+-------------------+------+------- vw_pois_ny_parks | geom | 4326 | POINT vw_pois_ny_parks | geom_2160 | 2160 | POINT
När du har skapat en spatial tabell är du redo att ladda upp spatiala data till databasen. Det finns två inbyggda sätt att få spatiala data till en PostGIS/PostgreSQL-databas: med hjälp av formaterade SQL-satser eller med hjälp av Shapefile-laddaren.
Om spatiala data kan konverteras till en textrepresentation (som antingen WKT eller WKB) kan SQL vara det enklaste sättet att få in data i PostGIS. Data kan bulk-laddas in i PostGIS/PostgreSQL genom att ladda en textfil med SQL INSERT-satser med hjälp av SQL-verktyget psql.
En SQL-laddningsfil (till exempelroads.sql) kan se ut så här:
BEGIN; INSERT INTO roads (road_id, roads_geom, road_name) VALUES (1, 'LINESTRING(191232 243118,191108 243242)', 'Jeff Rd'); INSERT INTO roads (road_id, roads_geom, road_name) VALUES (2, 'LINESTRING(189141 244158,189265 244817)', 'Geordie Rd'); INSERT INTO roads (road_id, roads_geom, road_name) VALUES (3, 'LINESTRING(192783 228138,192612 229814)', 'Paul St'); INSERT INTO roads (road_id, roads_geom, road_name) VALUES (4, 'LINESTRING(189412 252431,189631 259122)', 'Graeme Ave'); INSERT INTO roads (road_id, roads_geom, road_name) VALUES (5, 'LINESTRING(190131 224148,190871 228134)', 'Phil Tce'); INSERT INTO roads (road_id, roads_geom, road_name) VALUES (6, 'LINESTRING(198231 263418,198213 268322)', 'Dave Cres'); COMMIT;
SQL-filen kan laddas in i PostgreSQL med psql:
psql -d [database] -f roads.sql
Shp2pgsql-dataladdaren konverterar Shapefiles till SQL som är lämplig för införande i en PostGIS / PostgreSQL-databas antingen i geometri- eller geografiformat. Laddaren har flera driftlägen som väljs med kommandoradsflaggor.
The input must be an unpacked shapefile path. The loader does not read .zip archives directly; unpack the .shp, .shx, and .dbf files before loading.
Det finns också ett grafiskt gränssnitt shp2pgsql-gui med de flesta av alternativen som kommandoradsladdaren. Detta kan vara lättare att använda för engångsladdning utan skript eller om du är nybörjare på PostGIS. Det kan också konfigureras som ett plugin till PgAdminIII.
-cSkapar en ny tabell och fyller i den från Shapefilen. Detta är standardläget.
-aLägger till data från Shapefilen i databastabellen. Observera att filerna måste ha samma attribut och samma datatyper om du vill använda det här alternativet för att läsa in flera filer.
-dSlänger databastabellen innan en ny tabell skapas med data från Shapefilen.
-pProducerar endast SQL-koden för tabellskapande, utan att lägga till några faktiska data. Detta kan användas om du helt vill separera stegen för att skapa tabeller och läsa in data.
-?Visa hjälpskärm.
-DAnvänd PostgreSQL "dump" -formatet för utdata. Detta kan kombineras med -a, -c och -d. Det är mycket snabbare att läsa in än standard SQL-formatet "insert". Använd detta för mycket stora datamängder.
-f <fid_column>, --feature-id-column <fid_column>Specify the name of the feature id column. The default is gid. The value must be a simple PostgreSQL identifier and cannot use a PostgreSQL system column name.
-s [<FROM_SRID>:]<SRID>Skapar och fyller på geometritabellerna med den angivna SRID:en. Anger eventuellt att den ingående shapefilen använder den angivna FROM_SRID, i vilket fall geometrierna kommer att omprojiceras till mål-SRID.
-kBehåll identifierarnas versaler (kolumn, schema och attribut). Observera att alla attribut i Shapefile är UPPPPERCASE.
-iTvinga alla heltal till standard 32-bitars heltal, skapa inte 64-bitars bigints, även om DBF-headerns signatur verkar motivera det.
-ISkapa ett GiST-index på geometrikolumnen.
-uCreate the target table as UNLOGGED. This can speed up loading transient staging data, but PostgreSQL does not preserve unlogged table contents after a crash or unclean shutdown.
-mSpecify a file containing a set of mappings of (long) column names to 10 character DBF column names. The content of the file is one or more lines of two names separated by white space and no trailing or leading space. For example:
COLUMNNAME DBFFIELD1
AVERYLONGCOLUMNNAME DBFFIELD2
-SGenerera enkla geometrier i stället för MULTI-geometrier. Kommer endast att lyckas om alla geometrier faktiskt är enkla (t.ex. en MULTIPOLYGON med ett enda skal eller en MULTIPOINT med ett enda vertex).
-t <dimensionality>Tvingar utdatageometrin att ha den angivna dimensionaliteten. Använd följande strängar för att ange dimensionaliteten: 2D, 3DZ, 3DM, 4D.
Om indata har färre dimensioner än vad som anges, kommer dessa dimensioner att fyllas i med nollor i utdata. Om indata har fler dimensioner än vad som anges, kommer de oönskade dimensionerna att tas bort.
-wUtdata i WKT-format istället för WKB. Observera att detta kan medföra koordinatavvikelser på grund av förlorad precision.
-eExekvera varje sats för sig, utan att använda en transaktion. Detta gör det möjligt att läsa in majoriteten av bra data när det finns några dåliga geometrier som genererar fel. Observera att detta inte kan användas med flaggan -D eftersom "dump"-formatet alltid använder en transaktion.
-W <encoding>Ange kodning av indata (dbf-fil). När detta används konverteras alla attribut i dbf-filen från den angivna kodningen till UTF8. Den resulterande SQL-utdata kommer att innehålla ett SET CLIENT_ENCODING till UTF8-kommando, så att backend kan konvertera om från UTF8 till den kodning som databasen är konfigurerad att använda internt.
-N <policy>Policy för hantering av NULL-geometrier (insert*,skip,abort)
-n-n Importera endast DBF-fil. Om dina data inte har någon motsvarande shapefil kommer den automatiskt att växla till detta läge och bara läsa in dbf-filen. Så att ställa in denna flagga behövs bara om du har en fullständig shapefiluppsättning och du bara vill ha attributdata och ingen geometri.
-GAnvänd geografin i stället för geometrin (kräver lon/lat-data) i WGS84 long lat (SRID=4326)
-T <tablespace>Ange tablespace för den nya tabellen. Index kommer fortfarande att använda standardbordsytan om inte -X-parametern också används. PostgreSQL-dokumentationen har en bra beskrivning av när man ska använda anpassade tablespaces.
-X <tablespace>Ange tablespace för den nya tabellens index. Detta gäller för primärnyckelindexet och det spatiala GIST-indexet om -I också används.
-ZNär denna flagga används förhindrar den att ANALYZE-satser genereras. Utan flaggan -Z (standardbeteende) kommer ANALYZE-satserna att genereras.
Ett exempel på en session där laddaren används för att skapa en inmatningsfil och ladda den kan se ut så här:
shp2pgsql -c -D -s 4269 -i -I shaperoads.shp myschema.roadstable > roads.sql psql -d roadsdb -f roads.sql
En konvertering och laddning kan göras i ett steg med hjälp av UNIX pipes:
shp2pgsql shaperoads.shp myschema.roadstable | psql -d roadsdb
To load a directory of Shapefiles, run the loader once per file and derive the table name from the file name. On Windows cmd.exe, use a single percent sign interactively and double percent signs in a batch file:
REM In a .bat file, use %%F. At an interactive cmd.exe prompt, use %F.
for %%F in ("C:\data\shapefiles\*.shp") do (
shp2pgsql -d -D -s 4269 -I -W UTF-8 "%%~fF" "myschema.%%~nF" | psql -d roadsdb
)If every Shapefile has the same attributes and data types and should be appended into one table, create the table from the first file and use -a for the remaining files.
Spatiala data kan extraheras från databasen med hjälp av antingen SQL eller Shapefile-dumpern. I avsnittet om SQL presenteras några av de funktioner som finns tillgängliga för att göra jämförelser och frågor om spatiala tabeller.
Det enklaste sättet att extrahera spatiala data ur databasen är att använda en SQL SELECT-fråga för att definiera den datauppsättning som ska extraheras och dumpa de resulterande kolumnerna i en textfil som kan analyseras:
SELECT road_id,road_geom AS geom, road_name FROM roads;
road_id | geom | road_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)Det kommer att finnas tillfällen då någon form av begränsning är nödvändig för att minska antalet poster som returneras. När det gäller attributbaserade begränsningar använder du samma SQL-syntax som för en icke spatial tabell. När det gäller spatiala begränsningar är följande funktioner användbara:
ST_IntersectsDenna funktion visar om två geometrier delar på något utrymme.
=Detta testar om två geometrier är geometriskt identiska. Till exempel om "POLYGON((0 0,1 1,1 0,0 0))" är samma sak som "POLYGON((0 0,1 1,1 0,0 0))" (det är det).
Därefter kan du använda dessa operatorer i frågor. Observera att när du anger geometrier och boxar på SQL-kommandoraden måste du uttryckligen omvandla strängrepresentationerna till geometrier-funktionen. 312 är ett fiktivt spatialt referenssystem som matchar våra data. Så till exempel:
SELECT road_id, road_name FROM roads WHERE roads_geom='SRID=312;LINESTRING(191232 243118,191108 243242)'::geometry;
Ovanstående fråga skulle returnera den enda post från tabellen "ROADS_GEOM" där geometrin var lika med det värdet.
För att kontrollera om någon av vägarna passerar inom det område som definieras av en polygon:
SELECT road_id, road_name FROM roads WHERE ST_Intersects(roads_geom, 'SRID=312;POLYGON((...))');
Den vanligaste spatiala frågan kommer förmodligen att vara en "rambaserad" fråga som används av klientprogramvara, t.ex. webbläsare och webbmappare, för att hämta en "kartram" med data för visning.
När du använder operatorn "&&" kan du ange antingen en BOX3D som jämförelsefunktion eller en GEOMETRY. När du anger en GEOMETRY kommer dock dess bounding box att användas för jämförelsen.
Om du använder ett "BOX3D"-objekt som ram ser en sådan fråga ut så här:
SELECT roads_geom AS geom FROM roads WHERE roads_geom && ST_MakeEnvelope(191232, 243117,191232, 243119,312);
Notera användningen av SRID 312 för att specificera kuvertets projektion.
Tabelldumpern pgsql2shp ansluter till databasen och konverterar en tabell (eventuellt definierad av en fråga) till en shape-fil. Den grundläggande syntaxen är:
pgsql2shp [<options >] <database > [<schema >.]<table>
pgsql2shp [<options >] <database > <query>
Alternativen för kommandoraden är:
-f <filename>Skriv utdata till ett visst filnamn.
-h <host>Databasens värd att ansluta till.
-p <port>Porten att ansluta till på databasens värd.
-P <password>Det lösenord som ska användas vid anslutning till databasen.
-u <user>Det användarnamn som ska användas vid anslutning till databasen.
-g <geometry column>I tabeller med flera geometrikolumner, den geometrikolumn som ska användas när shape-filen skrivs.
-bAnvänd en binär markör. Detta gör operationen snabbare, men fungerar inte om något attribut i tabellen som inte är geometriskt saknar en cast till text.
-rRått läge. Släpp inte fältet gid eller escape kolumnnamn.
-m filenameOmvandla identifierare till namn med tio tecken. Filens innehåll består av rader med två symboler åtskilda av ett enda vitt mellanslag utan vare sig efterföljande eller inledande mellanslag: VERYLONGSYMBOL SHORTONE ANOTHERVERYLONGSYMBOL SHORTER etc.
Spatiala index gör det möjligt att använda en spatial databas för stora datamängder. Utan indexering kräver en sökning efter funktioner en sekventiell genomsökning av varje post i databasen. Indexering snabbar upp sökningen genom att organisera data i en struktur som snabbt kan genomgås för att hitta matchande poster.
Den indexmetod med B-träd som vanligen används för attributdata är inte särskilt användbar för spatiala data, eftersom den endast stöder lagring och sökning av data i en enda dimension. Data som geometri (som har två eller flera dimensioner) kräver en indexmetod som stöder intervallfråga över alla datadimensioner. En av de viktigaste fördelarna med PostgreSQL för spatial datahantering är att den erbjuder flera typer av indexmetoder som fungerar bra för flerdimensionella data: GiST-, BRIN- och SP-GiST-index.
GiST-index (Generalized Search Tree) delar upp data i "saker på ena sidan", "saker som överlappar", "saker som är inuti" och kan användas på ett brett spektrum av datatyper, inklusive GIS-data. PostGIS använder ett R-Tree-index som implementerats ovanpå GiST för att indexera spatiala data. GiST är den vanligaste och mest mångsidiga metoden för spatiala index och erbjuder mycket bra prestanda vid sökningar.
BRIN-index (Block Range Index) fungerar genom att sammanfatta den spatiala omfattningen av intervall av tabellposter. Sökningen görs via en skanning av intervallen. BRIN är endast lämpligt att använda för vissa typer av data (spatialt sorterade, med sällsynta eller inga uppdateringar). Men det ger mycket snabbare tid för att skapa index och mycket mindre indexstorlek.
SP-GiST (Space-Partitioned Generalized Search Tree) är en generisk indexmetod som stöder partitionerade sökträd som quad-trees, k-d-träd och radix-träd (tries).
Spatiala index lagrar endast geometriernas avgränsande box. Spatiala frågor använder indexet som ett primärt filter för att snabbt fastställa en uppsättning geometrier som potentiellt matchar frågevillkoret. De flesta spatiala frågor kräver ett sekundärt filter som använder en spatial predikatfunktion för att testa ett mer specifikt spatialt villkor. Mer information om hur du ställer frågor med spatiala predikat finns på Avsnitt 5.2, ”Använda spatiala index”.
Se även PostGIS Workshop-avsnittet om spatiala index och PostgreSQL-handboken.
GiST står för "Generalized Search Tree" och är en generisk form av indexering för flerdimensionella data. PostGIS använder ett R-Tree-index som implementerats ovanpå GiST för att indexera spatiala data. GiST är den vanligaste och mest mångsidiga metoden för spatial indexering och erbjuder mycket bra sökprestanda. Andra implementeringar av GiST används för att påskynda sökningar på alla typer av oregelbundna datastrukturer (heltalsarrayer, spektraldata etc.) som inte är mottagliga för normal B-Tree-indexering. För mer information se PostgreSQL-manualen.
När en spatial datatabell överstiger några tusen rader vill du bygga ett index för att påskynda spatiala sökningar av data (såvida inte alla dina sökningar baseras på attribut, i vilket fall du vill bygga ett normalt index på attributfälten).
Syntaxen för att bygga ett GiST-index på en "geometri"-kolumn är följande:
CREATE INDEX [indexname] ON [tablename] USING GIST ( [geometryfield]);
Syntaxen ovan skapar alltid ett 2D-index. Om du vill få ett n-dimensionellt index för geometritypen kan du skapa ett sådant med denna syntax:
CREATE INDEX [indexname] ON [tablename] USING GIST ([geometryfield] gist_geometry_ops_nd);
Att bygga ett spatialt index är en beräkningsintensiv övning. Det blockerar också skrivåtkomst till din tabell under den tid det skapas, så på ett produktionssystem kanske du vill göra det på ett långsammare CONCURRENTLY-medvetet sätt:
CREATE INDEX CONCURRENTLY [indexname] ON [tablename] USING GIST ( [geometryfield]);
Efter att ha byggt ett index är det ibland bra att tvinga PostgreSQL att samla in tabellstatistik, som används för att optimera frågeplaner:
VACUUM ANALYZE [table_name] [(column_name)];
BRIN stands for "Block Range Index". It is a general-purpose index method provided by PostgreSQL. BRIN is a lossy index method, meaning that a secondary check is required to confirm that a record matches a given search condition (which is the case for all provided spatial indexes). It provides much faster index creation and much smaller index size, with reasonable read performance. Its primary purpose is to support indexing very large tables on columns which have a correlation with their physical location within the table. In addition to spatial indexing, BRIN can speed up searches on various kinds of attribute data structures (integer, arrays etc). For more information see the PostgreSQL manual.
När en spatial tabell överstiger några tusen rader vill du bygga ett index för att påskynda spatiala sökningar av data. GiST-index är mycket effektiva så länge deras storlek inte överstiger mängden RAM-minne som är tillgängligt för databasen och så länge du har råd med indexets lagringsstorlek och kostnaden för indexuppdatering vid skrivning. I annat fall kan BRIN-index betraktas som ett alternativ för mycket stora tabeller.
Ett BRIN-index lagrar den avgränsande box som omsluter alla geometrier som finns i raderna i en sammanhängande uppsättning tabellblock, ett så kallat blockintervall. När en fråga körs med hjälp av indexet skannas blockområdena för att hitta dem som skär frågans utsträckning. Detta är effektivt endast om data är fysiskt ordnade så att blockintervallens avgränsande rutor har minimal överlappning (och helst är ömsesidigt uteslutande). Det resulterande indexet är mycket litet i storlek, men har vanligtvis sämre läsprestanda än ett GiST-index över samma data.
Att bygga ett BRIN-index är mycket mindre CPU-intensivt än att bygga ett GiST-index. Det är vanligt att ett BRIN-index är tio gånger snabbare att bygga än ett GiST-index över samma data. Och eftersom ett BRIN-index bara lagrar en bounding box för varje intervall av tabellblock, är det vanligt att det använder upp till tusen gånger mindre diskutrymme än ett GiST-index.
Du kan välja hur många block som ska sammanfattas i ett intervall. Om du minskar detta antal blir indexet större, men ger förmodligen bättre prestanda.
För att BRIN ska vara effektivt bör tabelldata lagras i en fysisk ordning som minimerar mängden överlappning av blockutbredningen. Det kan hända att data redan är sorterade på lämpligt sätt (t.ex. om de har laddats från en annan dataset som redan är sorterad i spatial ordning). Annars kan detta åstadkommas genom att sortera data efter en endimensionell spatial nyckel. Ett sätt att göra detta är att skapa en ny tabell sorterad efter geometrivärdena (som i de senaste PostGIS-versionerna använder en effektiv Hilbertkurvor-ordning):
CREATE TABLE table_sorted AS SELECT * FROM table ORDER BY geom;
Alternativt kan data sorteras på plats genom att använda en GeoHash som ett (tillfälligt) index och klustra på det indexet:
CREATE INDEX idx_temp_geohash ON table
USING btree (ST_GeoHash(ST_Transform(geom, 4326 ), 20));
CLUSTER table USING idx_temp_geohash;
Syntaxen för att bygga ett BRIN-index på en geometrikolumn är:
CREATE INDEX [indexname] ON [tablename] USING BRIN ( [geome_col]);
Syntaxen ovan skapar ett 2D-index. Om du vill bygga ett 3D-dimensionellt index använder du den här syntaxen:
CREATE INDEX [indexname] ON [tablename] USING BRIN ([geome_col] brin_geometry_inclusion_ops_3d);
Du kan också få ett 4D-dimensionellt index med hjälp av operatorsklassen 4D:
CREATE INDEX [indexname] ON [tablename] USING BRIN ([geome_col] brin_geometry_inclusion_ops_4d);
Ovanstående kommandon använder standardantalet block i ett intervall, vilket är 128. Om du vill ange antalet block som ska sammanfattas i ett intervall använder du följande syntax
CREATE INDEX [indexname] ON [tablename] USING BRIN ( [geome_col] ) WITH (pages_per_range = [number]);
Tänk på att ett BRIN-index bara lagrar en indexpost för ett stort antal rader. Om din tabell lagrar geometrier med ett blandat antal dimensioner är det troligt att det resulterande indexet kommer att ha dålig prestanda. Du kan undvika denna prestandaförlust genom att välja den operatorsklass som har minst antal dimensioner för de lagrade geometrierna
Datatypen geography stöds för BRIN-indexering. Syntaxen för att bygga ett BRIN-index på en geografikolumn är:
CREATE INDEX [indexname] ON [tablename] USING BRIN ( [geog_col]);
Syntaxen ovan bygger upp ett 2D-index för geospatiala objekt på sfäroiden.
För närvarande finns endast "inclusion support", vilket innebär att endast operatorerna &&, ~ och @ kan användas för 2D-fall (för både geometri och geografi), och endast operatorn &&& för 3D-geometrier. Det finns för närvarande inget stöd för kNN-sökningar.
En viktig skillnad mellan BRIN och andra indextyper är att databasen inte underhåller indexet dynamiskt. Ändringar av spatiala data i tabellen läggs helt enkelt till i slutet av indexet. Detta leder till att indexets sökprestanda försämras med tiden. Indexet kan uppdateras genom att utföra en VACUUM eller genom att använda en specialfunktion brin_summarize_new_values(regclass). Av denna anledning kan BRIN vara lämpligast att använda med data som är skrivskyddade eller endast sällan ändras. För mer information se manualen.
Sammanfattningsvis använder vi BRIN för spatiala data:
Indexet byggs upp mycket snabbt och indexets storlek är mycket liten.
Indexfrågetiden är långsammare än för GiST, men kan fortfarande vara mycket acceptabel.
Kräver att tabelldata sorteras i en spatial ordning.
Kräver manuellt indexunderhåll.
Lämpar sig bäst för mycket stora tabeller, med låg eller ingen överlappning (t.ex. punkter), som är statiska eller ändras sällan.
Mer effektiv för frågor som returnerar ett relativt stort antal dataposter.
SP-GiST står för "Space-Partitioned Generalized Search Tree" och är en generisk form av indexering för flerdimensionella datatyper som stöder partitionerade sökträd, t.ex. quad-trees, k-d trees och radix trees (tries). Gemensamt för dessa datastrukturer är att de upprepade gånger delar upp sökrymden i partitioner som inte behöver vara lika stora. Förutom spatial indexering används SP-GiST för att påskynda sökningar på många typer av data, till exempel telefonrouting, ip-routing, substringsökning etc. För mer information se PostgreSQL-manualen.
Liksom GiST-index är SP-GiST-index förlustbringande, i den meningen att de lagrar den avgränsande box som omger spatiala objekt. SP-GiST-index kan betraktas som ett alternativ till GiST-index.
När en GIS-datatabell överstiger några tusen rader kan ett SP-GiST-index användas för att påskynda spatiala sökningar av data. Syntaxen för att bygga ett SP-GiST-index på en "geometri"-kolumn är följande:
CREATE INDEX [indexname] ON [tablename] USING SPGIST ( [geometryfield]);
Syntaxen ovan bygger upp ett 2-dimensionellt index. Ett 3-dimensionellt index för geometritypen kan skapas med hjälp av operatorsklassen 3D:
CREATE INDEX [indexname] ON [tablename] USING SPGIST ([geometryfield] spgist_geometry_ops_3d);
Att bygga ett spatialt index är en beräkningsintensiv operation. Det blockerar också skrivåtkomst till din tabell under den tid det skapas, så på ett produktionssystem kanske du vill göra det på ett långsammare CONCURRENTLY-medvetet sätt:
CREATE INDEX CONCURRENTLY [indexname] ON [tablename] USING SPGIST ( [geometryfield]);
Efter att ha byggt ett index är det ibland bra att tvinga PostgreSQL att samla in tabellstatistik, som används för att optimera frågeplaner:
VACUUM ANALYZE [table_name] [(column_name)];
Ett SP-GiST-index kan påskynda frågor som involverar följande operatorer:
<<, &<, &>, >>, <<|, &<|, |&>, |>>, &&, @>, <@, och ~=, för 2-dimensionella index,
&/&, ~==, @>>, och <<@, för 3-dimensionella index.
Det finns för närvarande inget stöd för kNN-sökningar.
Vanligtvis påskyndar index osynligt dataåtkomst: när ett index har byggts bestämmer PostgreSQL-frågeplaneraren automatiskt när den ska användas för att förbättra frågeprestanda. Men det finns vissa situationer där planeraren inte väljer att använda befintliga index, så frågor slutar använda långsamma sekventiella skanningar istället för ett spatialt index.
Om du upptäcker att dina spatiala index inte används finns det några saker du kan göra:
Granska frågeplanen och kontrollera att din fråga faktiskt beräknar det du behöver. En felaktig JOIN, antingen bortglömd eller till fel tabell, kan oväntat hämta tabellposter flera gånger. För att få fram frågeplanen kör du med EXPLAIN framför frågan.
Se till att statistik samlas in om antalet och fördelningen av värden i en tabell, så att frågeplaneraren får bättre information för att fatta beslut om indexanvändning. VACUUM ANALYZE beräknar båda.
Du bör regelbundet dammsuga dina databaser ändå. Många PostgreSQL DBA: er kör VACUUM som ett cron-jobb utanför topparna regelbundet.
Om det inte hjälper att dammsuga kan du tillfälligt tvinga planeraren att använda indexinformationen genom att använda kommandot SET ENABLE_SEQSCAN TO OFF;. På så sätt kan du kontrollera om planeraren överhuvudtaget kan generera en indexaccelererad frågeplan för din fråga. Du bör bara använda det här kommandot för felsökning; i allmänhet vet planeraren bättre än du när index ska användas. När du har kört din fråga, glöm inte att köra SET ENABLE_SEQSCAN TO ON; så att planeraren fungerar normalt för andra frågor.
Om SET ENABLE_SEQSCAN TO OFF; hjälper din fråga att köras snabbare är din Postgres sannolikt inte inställd för din maskinvara. Om du tycker att planeraren har fel om kostnaden för sekventiella skanningar jämfört med indexskanningar kan du försöka minska värdet på RANDOM_PAGE_COST i postgresql.conf eller använda SET RANDOM_PAGE_COST TO 1.1;. Standardvärdet för RANDOM_PAGE_COST är 4,0. Prova att ställa in det på 1,1 (för SSD) eller 2,0 (för snabba magnetiska diskar). Om du sänker värdet blir det mer sannolikt att planeraren använder indexskanningar.
Om SET ENABLE_SEQSCAN TO OFF; inte hjälper din fråga kan det bero på att frågan använder en SQL construct som Postgres-planeraren ännu inte kan optimera. Det kan vara möjligt att skriva om frågan på ett sätt som planeraren kan hantera. Till exempel kanske en underfråga med en inline SELECT inte ger en effektiv plan, men kan eventuellt skrivas om med hjälp av en LATERAL JOIN.
Mer information finns i Postgres-manualens avsnitt om Query Planning.
Syftet med spatiala databaser är att kunna utföra sökningar i databasen som normalt kräver GIS-funktioner på skrivbordet. För att PostGIS ska kunna användas effektivt måste man veta vilka spatiala funktioner som finns tillgängliga, hur de ska användas i frågor och se till att lämpliga index finns på plats för att ge bra prestanda.
Spatiala relationer anger hur två geometrier interagerar med varandra. De är en grundläggande egenskap för att ställa frågor om geometri.
Enligt OpenGIS Simple Features Implementation Specification for SQL är "det grundläggande tillvägagångssättet för att jämföra två geometrier att göra parvisa tester av skärningarna mellan de två geometriernas inre, yttre och yttre delar och att klassificera förhållandet mellan de två geometrierna baserat på posterna i den resulterande 'skärningsmatrisen'"
I teorin om punktuppsättningstopologi kategoriseras punkterna i en geometri som är inbäddad i ett 2-dimensionellt rum i tre uppsättningar:
Gränsen för en geometri är uppsättningen av geometrier med nästa lägre dimension. För POINTs, som har dimensionen 0, är gränsen den tomma mängden. Gränsen för en LINESTRING är de två ändpunkterna. För POLYGONERär gränsen linjeverket för de yttre och inre ringarna.
Det inre av en geometri är de punkter i en geometri som inte ligger i begränsningen. För POINTsär det inre själva punkten. Det inre av en LINESTRING är den uppsättning punkter som finns mellan ändpunkterna. För POLYGONERär det inre den areella ytan inuti polygonen.
En geometris utsida är resten av det rum i vilket geometrin är inbäddad; med andra ord alla punkter som inte ligger i geometrins inre eller på dess gräns. Det är en 2-dimensionell icke sluten yta.
DE-9IM ( Dimensionally Extended 9-Intersection Model ) beskriver det spatiala förhållandet mellan två geometrier genom att ange dimensionerna för de 9 skärningspunkterna mellan ovanstående uppsättningar för varje geometri. Dimensionerna på skärningspunkterna kan formellt representeras i en 3x3 skärningsmatris.
För en geometri g betecknas det inre, det yttre och det yttre med beteckningarna I(g), B(g) och E(g). Dim(s) betecknar också dimensionen hos en mängd s med domänen {0,1,2,F}:
0 => punkt
1 => linje
2 => område
F => tom uppsättning
Med hjälp av denna notation är intersektionsmatrisen för två geometrier a och b: är:
| Inredning | Begränsning | Exteriör | |
|---|---|---|---|
| Inredning | dim( I(a) ∩ I(b) ) | dim( I(a) ∩ B(b) ) | dim( I(a) ∩ E(b) ) |
| Begränsning | dim( B(a) ∩ I(b) ) | dim( B(a) ∩ B(b) ) | dim( B(a) ∩ E(b) ) |
| Exteriör | dim( E(a) ∩ I(b) ) | dim( E(a) ∩ B(b) ) | dim( E(a) ∩ E(b) ) |
The following overlapping polygons provide a concrete example. ST_Relate computes the matrix 212101212; it matches the overlap pattern T*T***T** used by ST_Overlaps.
WITH example AS (
SELECT
'POLYGON ((140 140,140 122,135 105,126 100,118 99,110 94,100 86,97 73,102 59,98 49,87 38,70 30,55 29,40 30,28 38,20 50,14 66,10 84,6 100,4 119,4 143,6 166,10 180,18 191,28 195,40 190,55 189,67 186,86 179,112 165,124 158,133 148,140 140),(48 177,40 177,30 174,24 166,22 159,25 155,30 153,40 154,45 157,52 162,53 169,51 174,48 177))'::geometry AS a,
'POLYGON ((75 63,79 50,87 38,95 31,108 25,124 22,140 18,154 11,166 6,176 10,184 21,188 35,190 58,190 82,193 104,190 121,185 139,178 154,166 163,154 171,139 172,124 171,112 165,96 152,92 142,92 126,86 116,79 110,75 104,72 94,73 86,75 76,75 63))'::geometry AS b
), relation AS (
SELECT a, b, ST_Relate(a, b) AS matrix
FROM example
)
SELECT matrix,
ST_RelateMatch(matrix, 'T*T***T**') AS matches_overlap_pattern,
ST_Overlaps(a, b) AS overlaps
FROM relation;matrix | matches_overlap_pattern | overlaps -----------+-------------------------+---------- 212101212 | t | t (1 row)
The executable query and generated overlay above are the visual source for the relation. The query below renders the nine cells of the same kind of matrix as a 3-by-3 set of examples. The final exterior/exterior cell is clipped to a finite viewport, since the true exterior/exterior intersection is unbounded.
WITH example AS (
SELECT
ST_MakeEnvelope(0, 0, 6, 4) AS a,
ST_MakeEnvelope(3, -1, 8, 3) AS b,
ST_MakeEnvelope(-1, -2, 9, 5) AS viewport
), parts AS (
SELECT
a,
b,
ST_Boundary(a) AS ba,
ST_Boundary(b) AS bb,
viewport
FROM example
)
SELECT
ST_Relate(a, b) AS matrix,
ST_AsText(ST_Normalize(a)) AS input_a,
ST_AsText(ST_Normalize(b)) AS input_b,
ST_AsText(ST_Normalize(ST_Intersection(a, b))) AS "2 I(a) ∩ I(b)",
ST_AsText(ST_Normalize(ST_Intersection(a, bb))) AS "1 I(a) ∩ B(b)",
ST_AsText(ST_Normalize(ST_Difference(a, b))) AS "2 I(a) ∩ E(b)",
ST_AsText(ST_Normalize(ST_Intersection(ba, b))) AS "1 B(a) ∩ I(b)",
ST_AsText(ST_Normalize(ST_Intersection(ba, bb))) AS "0 B(a) ∩ B(b)",
ST_AsText(ST_Normalize(ST_Collect(
'LINESTRING(0 0,0 4,6 4,6 3)'::geometry,
'LINESTRING(0 0,3 0)'::geometry
))) AS "1 B(a) ∩ E(b)",
ST_AsText(ST_Normalize(ST_Difference(b, a))) AS "2 E(a) ∩ I(b)",
ST_AsText(ST_Normalize(ST_Collect(
'LINESTRING(3 -1,8 -1,8 3,6 3)'::geometry,
'LINESTRING(3 -1,3 0)'::geometry
))) AS "1 E(a) ∩ B(b)",
ST_AsText(ST_Normalize(ST_Difference(viewport, ST_Union(a, b))))
AS "2 E(a) ∩ E(b) clipped"
FROM parts;När man läser från vänster till höger och uppifrån och ner representeras skärningsmatrisen av textsträngen '"212101212".'.
För mer information, se:
För att göra det enkelt att fastställa vanliga spatiala relationer definierar OGC SFS en uppsättning namngivna predikat för spatiala relationer. PostGIS tillhandahåller dessa som funktionerna ST_Contains, ST_Crosses, ST_Disjoint, ST_Equals, ST_Intersects, ST_Overlaps, ST_Touches, ST_Within. Det definierar också de icke-standardiserade relationspredikaten ST_Covers, ST_CoveredBy, och ST_ContainsProperly.
Spatiala predikat används vanligtvis som villkor i SQL WHERE- eller JOIN-klausuler. De namngivna spatiala predikaten använder automatiskt ett spatialt index om ett sådant finns tillgängligt, så det finns inget behov av att använda bounding box-operatorn && också. Till exempel:
SELECT city.name, state.name, city.geom FROM city JOIN state ON ST_Intersects(city.geom, state.geom);
För mer information och illustrationer, se PostGIS Workshop.
In some cases the named spatial relationships are insufficient to provide a desired spatial filter condition. These requirements can be expressed by computing the full DE-9IM intersection matrix with ST_Relate.
För att testa ett visst spatialt förhållande används ett intersektionsmatrismönster. Detta är matrisrepresentationen utökad med tilläggssymbolerna {T,*}:
T => intersection dimension is non-empty; i.e. is in {0,1,2}
* => bryr sig inte
Using intersection matrix patterns, specific spatial relationships can be evaluated succinctly. The ST_Relate and ST_RelateMatch functions can both test these patterns.
These road segments share a line segment. ST_Crosses does not find this relationship for linear features, because it only returns true when their interiors intersect at a point. The pattern 1*1***1** tests for a one-dimensional intersection instead.
WITH roads AS (
SELECT
'LINESTRING(10 10,40 90,70 110,140 110,170 130,190 190)'::geometry AS "road A",
'LINESTRING(10 190,50 130,90 110,130 110,160 70,180 10)'::geometry AS "road B"
), relation AS (
SELECT "road A", "road B", ST_Relate("road A", "road B") AS matrix
FROM roads
)
SELECT
ST_Intersection("road A", "road B") AS overlap,
matrix,
ST_Crosses("road A", "road B") AS "ST_Crosses",
ST_RelateMatch(matrix, '1*1***1**') AS "matches 1*1***1**"
FROM relation;overlap | matrix | ST_Crosses | matches 1*1***1** ----------------------------+-----------+------------+------------------- LINESTRING(90 110,130 110) | 1F1FF0102 | f | t (1 row)
The next example finds a wharf which runs from the lake interior onto its shoreline, with one endpoint on the shoreline. The other wharves provide nearby counterexamples in the figure. The pattern 102101FF2 expresses the complete required relationship in one test.
WITH data AS (
SELECT
'POLYGON((-20 10,30 30,80 70,110 80,145 85,190 110,300 220,230 220,-20 220,-20 10))'::geometry AS lake,
'MULTILINESTRING((120 180,145 85,110 80),(10 130,30 70),(90 140,110 80,94.81118881118876 75.83496503496498),(150 160,180 80))'::geometry AS wharves
), wharf AS (
SELECT lake, (item).path[1] AS id, (item).geom
FROM data CROSS JOIN LATERAL ST_Dump(wharves) AS item
), relation AS (
SELECT id, geom, ST_Relate(lake, geom) AS matrix
FROM wharf
)
SELECT
id AS wharf,
geom AS "matching wharf",
matrix
FROM relation
WHERE ST_RelateMatch(matrix, '102101FF2')
ORDER BY id;wharf | matching wharf | matrix
-------+-----------------------------------+-----------
1 | LINESTRING(120 180,145 85,110 80) | 102101FF2
(1 row)När du konstruerar frågor med spatiala villkor är det viktigt att se till att ett spatialt index används, om ett sådant finns (se Avsnitt 4.9, ”Spatiala index”), för bästa prestanda. För att göra detta måste en spatial operator eller en indexmedveten funktion användas i en WHERE- eller ON-sats i frågan.
Spatiala operatorer inkluderar bounding box-operatorer (av vilka den vanligaste är &&; se Avsnitt 7.10.1, ”Operatorer för avgränsande box” för en fullständig lista) och avståndsoperatorer som används i frågor om närmaste granne (den vanligaste är <->; se Avsnitt 7.10.2, ”Avståndsoperatorer” för en fullständig lista)
Indexmedvetna funktioner lägger automatiskt till en bounding box-operator till det spatiala villkoret. Indexmedvetna funktioner inkluderar de namngivna spatiala relationspredikaten ST_Contains, ST_ContainsProperly, ST_CoveredBy, ST_Covers, ST_Crosses, ST_Intersects, ST_Overlaps, ST_Touches, ST_Within, ST_Within, och ST_3DIntersects, och avståndspredikaten ST_DWithin, ST_DFullyWithin, ST_3DDFullyWithin, och ST_3DDWithin.)
Funktioner som ST_Distance använder inte index för att optimera sin drift. Till exempel skulle följande fråga vara ganska långsam på en stor tabell:
SELECT geom FROM geom_table WHERE ST_Distance(geom, 'SRID=312;POINT(100000 200000)') < 100
Denna fråga väljer ut alla geometrier i geom_table som ligger inom 100 enheter från punkten (100000, 200000). Den kommer att vara långsam eftersom den beräknar avståndet mellan varje punkt i tabellen och den angivna punkten, dvs. en ST_Distance() -beräkning görs för varje rad i tabellen.
Antalet rader som bearbetas kan minskas avsevärt genom att använda den indexmedvetna funktionen ST_DWithin:
SELECT geom FROM geom_table WHERE ST_DWithin(geom, 'SRID=312;POINT(100000 200000)', 100)
Denna fråga väljer samma geometrier, men den gör det på ett effektivare sätt. Detta möjliggörs genom att ST_DWithin() använder &&-operatorn internt på en utökad begränsningsbox för frågegegeometrin. Om det finns ett spatialt index på geom kommer frågeplaneraren att inse att den kan använda indexet för att minska antalet rader som skannas innan avståndet beräknas. Det spatiala indexet gör det möjligt att endast hämta poster med geometrier vars avgränsande rutor överlappar den expanderade omfattningen och som därför kan ligga inom det avstånd som krävs. Det faktiska avståndet beräknas sedan för att bekräfta om posten ska inkluderas i resultatuppsättningen.
För mer information och exempel, se PostGIS Workshop.
I exemplen i detta avsnitt används en tabell med linjära vägar och en tabell med polygonala kommungränser. Definitionen av tabellen bc_roads är:
Column | Type | Description ----------+-------------------+------------------- gid | integer | Unique ID name | character varying | Road Name geom | geometry | Location Geometry (Linestring)
Definitionen av tabellen bc_municipality är:
Column | Type | Description ---------+-------------------+------------------- gid | integer | Unique ID code | integer | Unique ID name | character varying | City / Town Name geom | geometry | Location Geometry (Polygon)
5.3.1. | Vad är den totala längden på alla vägar, uttryckt i kilometer? |
Du kan besvara den här frågan med ett mycket enkelt SQL-test: Code SELECT sum(ST_Length(geom))/1000 AS km_roads FROM bc_roads; Rasterutdata km_roads ------------------ 70842.1243039643 | |
5.3.2. | Hur stor är staden Prince George, räknat i hektar? |
Denna fråga kombinerar ett attributvillkor (på kommunens namn) med en spatial beräkning (av polygonområdet): Code SELECT ST_Area(geom)/10000 AS hectares FROM bc_municipality WHERE name = 'PRINCE GEORGE'; Rasterutdata hectares ------------------ 32657.9103824927 | |
5.3.3. | Vilken är den största kommunen i provinsen, sett till ytan? |
Denna fråga använder en spatial mätning som ett ordningsvärde. Det finns flera sätt att närma sig detta problem, men det mest effektiva är nedan: Code SELECT name, ST_Area(geom)/10000 AS hectares FROM bc_municipality ORDER BY hectares DESC LIMIT 1; Rasterutdata name | hectares ---------------+----------------- TUMBLER RIDGE | 155020.02556131 Observera att vi måste beräkna arean för varje polygon för att kunna besvara den här frågan. Om vi gjorde det här mycket skulle det vara vettigt att lägga till en områdeskolumn i tabellen som kan indexeras för prestanda. Genom att beställa resultaten i fallande riktning och använda PostgreSQL-kommandot "LIMIT" kan vi enkelt välja bara det största värdet utan att använda en aggregerad funktion som MAX (). | |
5.3.4. | Hur långa är de vägar som helt och hållet ingår i varje kommun? |
Detta är ett exempel på en "spatial join", som sammanför data från två tabeller (med en join) med hjälp av en spatial interaktion ("contained") som join-villkor (i stället för den vanliga relationella metoden med join på en gemensam nyckel): Code SELECT m.name, sum(ST_Length(r.geom))/1000 as roads_km FROM bc_roads AS r JOIN bc_municipality AS m ON ST_Contains(m.geom, r.geom) GROUP BY m.name ORDER BY roads_km; Rasterutdata name | roads_km ----------------------------+---------- SURREY | 1539.476 VANCOUVER | 1450.331 LANGLEY DISTRICT | 833.793 BURNABY | 773.769 PRINCE GEORGE | 694.376 ... Den här frågan tar ett tag, eftersom varje väg i tabellen sammanfattas i slutresultatet (ca 250 000 vägar för exempeltabellen). För mindre dataset (flera tusen poster på flera hundra) kan svaret vara mycket snabbt. | |
5.3.5. | Skapa en ny tabell med alla vägar inom staden Prince George. |
Detta är ett exempel på en "overlay", som tar in två tabeller och matar ut en ny tabell som består av spatialt klippta eller skurna resultat. Till skillnad från den "spatial join" som demonstreras ovan skapar den här frågan nya geometrier. En overlay är som en turboladdad spatial join och är användbar för mer exakt analysarbete: Code CREATE TABLE pg_roads as SELECT ST_Intersection(r.geom, m.geom) AS intersection_geom, ST_Length(r.geom) AS rd_orig_length, r.* FROM bc_roads AS r JOIN bc_municipality AS m ON ST_Intersects(r.geom, m.geom) WHERE m.name = 'PRINCE GEORGE'; | |
5.3.6. | Hur lång är "Douglas St" i Victoria i kilometer? |
Code SELECT sum(ST_Length(r.geom))/1000 AS kilometers FROM bc_roads r JOIN bc_municipality m ON ST_Intersects(m.geom, r.geom WHERE r.name = 'Douglas St' AND m.name = 'VICTORIA'; Rasterutdata kilometers ------------------ 4.89151904172838 | |
5.3.7. | Vilken är den största kommunpolygonen som har ett hål? |
Code SELECT gid, name, ST_Area(geom) AS area FROM bc_municipality WHERE ST_NRings(geom) > 1 ORDER BY area DESC LIMIT 1; Rasterutdata gid | name | area -----+--------------+------------------ 12 | SPALLUMCHEEN | 257374619.430216 |
Current PostgreSQL versions suffer from a query optimizer weakness regarding TOAST tables. TOAST tables are a kind of "extension room" used to store large (in the sense of data size) values that do not fit into normal data pages (like long texts, images or complex geometries with lots of vertices), see the PostgreSQL Documentation for TOAST for more information).
Problemet uppstår om du råkar ha en tabell med ganska stora geometrier, men inte alltför många rader av dem (som en tabell som innehåller gränserna för alla europeiska länder i hög upplösning). Då är själva tabellen liten, men den använder massor av TOAST-utrymme. I vårt exempel hade tabellen i sig cirka 80 rader och använde bara 3 datasidor, men TOAST-tabellen använde 8225 sidor.
Ställ nu en fråga där du använder geometrioperatorn & & för att söka efter en avgränsningsbox som bara matchar mycket få av dessa rader. Nu ser frågeoptimeraren att tabellen bara har 3 sidor och 80 rader. Den uppskattar att en sekventiell skanning på en så liten tabell är mycket snabbare än att använda ett index. Och så beslutar den att ignorera GIST-indexet. Vanligtvis är denna uppskattning korrekt. Men i vårt fall måste operatorn hämta varje geometri från disken för att jämföra begränsningsrutorna, vilket innebär att alla TOAST-sidor också måste läsas.
För att se om du lider av den här frågan, använd kommandot "EXPLAIN ANALYZE" postgresql. För mer information och de tekniska detaljerna kan du läsa tråden på PostgreSQL-prestandans e-postlista: http://archives.postgresql.org/pgsql-performance/2005-02/msg00030.php
och nyare tråd om PostGIS https://lists.osgeo.org/pipermail/postgis-devel/2017-June/026209.html
PostgreSQL-folket försöker lösa detta problem genom att göra frågeuppskattningen TOAST-medveten. För närvarande är här två lösningar:
Den första lösningen är att tvinga frågeplaneraren att använda indexet. Skicka "SET enable_seqscan TO off;" till servern innan du skickar frågan. Detta tvingar i princip frågeplaneraren att undvika sekventiella skanningar när det är möjligt. Så den använder GIST-indexet som vanligt. Men den här flaggan måste ställas in för varje anslutning, och det gör att frågeplaneraren gör felbedömningar i andra fall, så du bör "SET enable_seqscan TO on;" efter frågan.
Den andra lösningen är att göra den sekventiella skanningen så snabb som frågeplaneraren tror. Detta kan uppnås genom att skapa en extra kolumn som "cachelagrar" bboxen och matchar mot denna. I vårt exempel ser kommandona ut så här:
SELECT AddGeometryColumn('myschema', 'mytable', 'bbox', '4326', 'GEOMETRY', '2');
UPDATE mytable SET bbox = ST_Envelope(ST_Force2D(geom));Ändra nu din fråga för att använda operatorn & & mot bbox istället för geom_column, som:
SELECT geom_column
FROM mytable
WHERE bbox && ST_SetSRID('BOX3D(0 0,1 1)'::box3d,4326);
Om du ändrar eller lägger till rader i min tabell måste du naturligtvis hålla bbox "synkroniserad". Det mest transparenta sättet att göra detta skulle vara triggers, men du kan också ändra din applikation för att hålla bbox-kolumnen aktuell eller köra UPDATE-frågan ovan efter varje ändring.
The PostgreSQL CLUSTER command physically reorders table rows according to an index. For a mostly read-only table whose queries frequently use the same spatial index, this can reduce I/O and improve cache locality.
PostgreSQL supports clustering on GiST indices, including indices on nullable geometry columns. To cluster a table using a geometry index:
CLUSTER my_table USING my_geom_index;
CLUSTER
Ibland råkar du ha 3D- eller 4D-data i din tabell, men du kommer alltid åt dem med OpenGIS-kompatibla ST_AsText()- eller ST_AsBinary()-funktioner som bara matar ut 2D-geometrier. De gör detta genom att internt anropa funktionen ST_Force2D(), som medför en betydande overhead för stora geometrier. För att undvika denna overhead kan det vara möjligt att i förväg släppa dessa extra dimensioner en gång för alla:
UPDATE mytable SET geom = ST_Force2D(geom); VACUUM FULL ANALYZE mytable;
Observera att om du har lagt till din geometrikolumn med AddGeometryColumn() kommer det att finnas en begränsning för geometridimensionen. För att kringgå den måste du släppa begränsningen. Kom ihåg att uppdatera posten i geometry_columns-tabellen och återskapa begränsningen efteråt.
När det gäller stora tabeller kan det vara klokt att dela upp denna UPDATE i mindre delar genom att begränsa UPDATE till en del av tabellen via en WHERE-klausul och din primära nyckel eller andra genomförbara kriterier och köra en enkel "VACUUM;" mellan dina UPDATE. Detta minskar drastiskt behovet av tillfälligt diskutrymme. Om du har geometrier med blandade dimensioner kan du dessutom begränsa UPDATE med "WHERE dimension(geom)>2" och slippa skriva om geometrier som redan finns i 2D.
De funktioner som anges nedan är de som en användare av PostGIS sannolikt kommer att behöva. Det finns andra funktioner som är nödvändiga stödfunktioner för PostGIS-objekten och som inte är till nytta för en allmän användare.
![]() | |
PostGIS har påbörjat en övergång från den befintliga namngivningskonventionen till en SQL-MM-centrerad konvention. Som ett resultat av detta har de flesta av de funktioner som du känner till och älskar bytt namn med hjälp av standardprefixet för spatial typ (ST). Tidigare funktioner är fortfarande tillgängliga, men listas inte i detta dokument där uppdaterade funktioner är likvärdiga. De ST_-funktioner som inte listas i den här dokumentationen är föråldrade och kommer att tas bort i en framtida version, så SLUTA ANVÄNDA DEM. |
I det här avsnittet listas de anpassade PostgreSQL-datatyperna som installerats av PostGIS för att representera spatiala data.
Varje datatyp beskriver sitt type casting-beteende. En type cast konverterar värden av en datatyp till en annan typ. PostgreSQL tillåter att definiera casting-beteende för anpassade typer, tillsammans med de funktioner som används för att konvertera typvärden. Casts kan ha automatiskt beteende, vilket möjliggör automatisk konvertering av ett funktionsargument till en typ som stöds av funktionen.
Vissa casts har ett explicit beteende, vilket innebär att castet måste anges med syntaxen CAST(myval As sometype ) eller myval::sometype. Explicit casting undviker problemet med tvetydiga casts, som kan uppstå när man använder en överladdad funktion som inte stöder en viss typ. En funktion kan t.ex. acceptera en box2d eller en box3d, men inte en geometry. Eftersom geometry har en automatisk cast till båda box-typerna, ger detta ett "tvetydig funktion"-fel. För att förhindra felet ska du använda en explicit cast till önskad box-typ.
Alla datatyper kan castas till text, så detta behöver inte anges explicit.
box2d — Typ som representerar en 2-dimensionell avgränsande box.
box2d är en spatial datatyp som används för att representera den tvådimensionella begränsningsbox som omsluter en geometri eller en samling geometrier. Aggregatfunktionen ST_Extent returnerar t.ex. ett box2d-objekt.
Representationen innehåller värdena xmin, ymin, xmax, ymax. Dessa är minimi- och maximivärdena för X- och Y-utsträckningarna.
box2d-objekt har en textrepresentation som ser ut som BOX(1 2,5 6)..
I denna tabell listas de automatiska och explicita casts som är tillåtna för denna datatyp:
| Kasta till | Beteende |
|---|---|
| box3d | automatisk |
| geometri | automatisk |
box3d — Typ som representerar en 3-dimensionell avgränsande box.
box3d är en spatial datatyp i PostGIS som används för att representera den tredimensionella begränsningsbox som omsluter en geometri eller en samling geometrier. Aggregatfunktionen ST_3DExtent returnerar till exempel ett box3d-objekt.
Representationen innehåller värdena xmin, ymin, zmin, xmax, ymax, zmax. Dessa är minimi- och maximivärdena för X-, Y- och Z-utsträckningarna.
box3d-objekt har en textrepresentation som ser ut som BOX3D(1 2 3,5 6 5)..
I denna tabell listas de automatiska och explicita casts som är tillåtna för denna datatyp:
| Kasta till | Beteende |
|---|---|
| box | automatisk |
| box2d | automatisk |
| geometri | automatisk |
geometry — Den typ som representerar spatiala egenskaper med plana koordinatsystem.
geometry är en grundläggande spatial datatyp i PostGIS som används för att representera en egenskap i plana (euklidiska) koordinatsystem.
Alla spatiala operationer på geometri använder enheterna i det spatiala referenssystem som geometrin befinner sig i.
I denna tabell listas de automatiska och explicita casts som är tillåtna för denna datatyp:
| Kasta till | Beteende |
|---|---|
| box | automatisk |
| box2d | automatisk |
| box3d | automatisk |
| bytea | automatisk |
| geografi | automatisk |
| text | automatisk |
geometry_dump — En sammansatt typ som används för att beskriva delarna i en komplex geometri.
geometry_dump är en sammansatt datatyp som innehåller fälten:
geom - en geometri som representerar en komponent i den dumpade geometrin. Geometritypen beror på den ursprungliga funktionen.
path[] - en heltalsarray som definierar navigeringsvägen inom den dumpade geometrin till geom-komponenten. Path-arrayen är 1-baserad (d.v.s. path [1] är det första elementet)
Den används av ST_Dump*-familjen av funktioner som en utdatatyp för att bryta ner en komplex geometri i sina beståndsdelar.
geography — Den typ som representerar spatiala egenskaper med geodetiska (ellipsoidiska) koordinatsystem.
geography är en spatial datatyp som används för att representera en funktion i geodetiska koordinatsystem. Geodetiska koordinatsystem modellerar jorden med hjälp av en ellipsoid.
Spatiala operationer på den geografiska typen ger mer exakta resultat genom att ta hänsyn till den ellipsoidiska modellen.
I denna tabell listas de automatiska och explicita casts som är tillåtna för denna datatyp:
| Kasta till | Beteende |
|---|---|
| geometri | explicit |
Dessa funktioner hjälper till att definiera tabeller som innehåller geometrikolumner.
AddGeometryColumn — Lägger till en geometrikolumn i en befintlig tabell.
text AddGeometryColumn(varchar table_name, varchar column_name, integer srid, varchar type, integer dimension, boolean use_typmod=true);
text AddGeometryColumn(varchar schema_name, varchar table_name, varchar column_name, integer srid, varchar type, integer dimension, boolean use_typmod=true);
text AddGeometryColumn(varchar catalog_name, varchar schema_name, varchar table_name, varchar column_name, integer srid, varchar type, integer dimension, boolean use_typmod=true);
Lägger till en geometrikolumn i en befintlig tabell med attribut. Schema_name är namnet på tabellschemat. Srid måste vara en heltalsreferens till en post i tabellen SPATIAL_REF_SYS. Type måste vara en sträng som motsvarar geometritypen, t.ex. "POLYGON" eller "MULTILINESTRING". Ett fel uppstår om schemanamnet inte finns (eller inte är synligt i den aktuella sökvägen) eller om den angivna SRID:en, geometritypen eller dimensionen är ogiltig.
Ändrad: 2.0.0 Den här funktionen uppdaterar inte längre geometry_columns eftersom geometry_columns är en vy som läser från systemkataloger. Som standard skapar det inte heller begränsningar, utan använder istället det inbyggda typmodifieringsbeteendet för PostgreSQL. Så till exempel att bygga en wgs84 POINT-kolumn med den här funktionen motsvarar nu: ALTER TABLE some_table ADD COLUMN geom geometry (Point,4326);
Ändrad: 2.0.0 Om du vill ha det gamla beteendet för begränsningar, använd standardvärdet use_typmod, men sätt det till false.
Ändrad: 2.0.0 Vyer kan inte längre registreras manuellt i geometry_columns, men vyer som är byggda mot geometri typmod-tabellgeometrier och används utan omslagsfunktioner kommer att registrera sig korrekt eftersom de ärver typmod-beteendet för sin överordnade tabellkolumn. Vyer som använder geometrifunktioner som matar ut andra geometrier måste castas till typmod-geometrier för att dessa vygeometrikolumner ska registreras korrekt i geometry_columns. Se Avsnitt 4.6.3, ”Manuell registrering av geometrikolumner”.
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
Förbättrad: 2.0.0 use_typmod-argumentet infördes. Standard är att skapa typmod-geometrikolumn istället för begränsningsbaserad.
This example creates a schema to hold data.
CREATE SCHEMA my_schema;
Create a simple PostgreSQL table in the schema.
CREATE TABLE my_schema.my_spatial_table (id serial);
Describing the table shows a single id column.
\d my_schema.my_spatial_table
Table "my_schema.my_spatial_table"
Column | Type | Modifiers
--------+---------+-------------------------------------------------------------------------
id | integer | not null default nextval('my_schema.my_spatial_table_id_seq'::regclass)Add a spatial column to the table.
SELECT AddGeometryColumn('my_schema', 'my_spatial_table', 'geom', 4326, 'POINT', 2);Add a point column using the old constraint-based behavior.
SELECT AddGeometryColumn('my_schema', 'my_spatial_table', 'geom_c', 4326, 'POINT', 2, false);Add a CurvePolygon column using the old constraint-based behavior.
SELECT AddGeometryColumn('my_schema', 'my_spatial_table', 'geomcp_c', 4326, 'CURVEPOLYGON', 2, false);my_schema.my_spatial_table.geomcp_c SRID:4326 TYPE:CURVEPOLYGON DIMS:2
Describe the table again to see the new geometry columns.
\d my_schema.my_spatial_table
Table "my_schema.my_spatial_table"
Columns:
id integer not null default nextval('my_schema.my_spatial_table_id_seq'::regclass)
geom geometry(Point,4326)
geom_c geometry
geomcp_c geometry
Check constraints:
"enforce_dims_geom_c" CHECK (st_ndims(geom_c) = 2)
"enforce_dims_geomcp_c" CHECK (st_ndims(geomcp_c) = 2)
"enforce_geotype_geom_c" CHECK (geometrytype(geom_c) = 'POINT'::text OR geom_c IS NULL)
"enforce_geotype_geomcp_c" CHECK (geometrytype(geomcp_c) = 'CURVEPOLYGON'::text OR geomcp_c IS NULL)
"enforce_srid_geom_c" CHECK (st_srid(geom_c) = 4326)
"enforce_srid_geomcp_c" CHECK (st_srid(geomcp_c) = 4326)The geometry_columns view also registers the new columns.
SELECT f_geometry_column As col_name, type, srid, coord_dimension As ndims FROM geometry_columns WHERE f_table_name = 'my_spatial_table' AND f_table_schema = 'my_schema';
col_name | type | srid | ndims ----------+--------------+------+------- geom | Point | 4326 | 2 geom_c | Point | 4326 | 2 geomcp_c | CurvePolygon | 4326 | 2
DropGeometryColumn — Tar bort en geometrikolumn från en spatial tabell.
text DropGeometryColumn(varchar table_name, varchar column_name);
text DropGeometryColumn(varchar schema_name, varchar table_name, varchar column_name);
text DropGeometryColumn(varchar catalog_name, varchar schema_name, varchar table_name, varchar column_name);
Tar bort en geometrikolumn från en spatial tabell. Observera att schema_name måste matcha fältet f_table_schema i tabellens rad i tabellen geometry_columns.
![]() | |
|
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
Changed: 2.0.0. Retained for backward compatibility after geometry_columns became a view of the system catalogs.
Use standard SQL to drop the geometry column. The geometry_columns view updates automatically.
ALTER TABLE my_schema.my_spatial_table DROP COLUMN geom;
The legacy compatibility function performs the equivalent operation.
SELECT DropGeometryColumn ('my_schema', 'my_spatial_table', 'geom');my_schema.my_spatial_table.geom effectively removed.
DropGeometryTable — Tar bort en tabell och alla dess referenser i geometry_columns.
boolean DropGeometryTable(varchar table_name);
boolean DropGeometryTable(varchar schema_name, varchar table_name);
boolean DropGeometryTable(varchar catalog_name, varchar schema_name, varchar table_name);
Slopar en tabell och alla dess referenser i geometry_columns. Observera: använder current_schema() på schemamedvetna pgsql-installationer om schema inte har angetts.
![]() | |
|
Changed: 2.0.0. Retained for backward compatibility after geometry_columns became a view of the system catalogs.
Use standard SQL to drop a table containing geometry columns. The geometry_columns view updates automatically.
DROP TABLE my_schema.my_spatial_table;
The legacy compatibility function performs the equivalent operation.
SELECT DropGeometryTable ('my_schema', 'my_spatial_table');my_schema.my_spatial_table dropped.
Find_SRID — Returnerar den SRID som definierats för en geometrikolumn.
integer Find_SRID(varchar a_schema_name, varchar a_table_name, varchar a_geomfield_name);
Returnerar heltals-SRID för den angivna geometrikolumnen genom sökning i tabellen GEOMETRY_COLUMNS. Om geometrikolumnen inte har lagts till på rätt sätt (t.ex. med funktionen AddGeometryColumn ) fungerar inte denna funktion.
SELECT Find_SRID('public', 'tiger_us_state_2007', 'geom_4269');4269
Populate_Geometry_Columns — Säkerställer att geometrikolumner definieras med typmodifierare eller har lämpliga spatiala begränsningar.
text Populate_Geometry_Columns(boolean use_typmod=true);
int Populate_Geometry_Columns(oid relation_oid, boolean use_typmod=true);
Säkerställer att geometrikolumner har lämpliga typmodifierare eller spatiala begränsningar för att säkerställa att de registreras korrekt i vyn geometry_columns. Som standard konverteras alla geometrikolumner utan typmodifierare till sådana med typmodifierare.
För bakåtkompatibilitet och för spatiala behov, t.ex. tabellarv där varje underordnad tabell kan ha olika geometrityp, stöds fortfarande det gamla check constraint-beteendet. Om du behöver det gamla beteendet måste du skicka in det nya valfria argumentet som false use_typmod=false. När detta görs kommer geometrikolumner att skapas utan typmodifierare men med 3 definierade begränsningar. Detta innebär i synnerhet att varje geometrikolumn som tillhör en tabell har minst tre begränsningar:
enforce_dims_geom - säkerställer att varje geometri har samma dimension (se ST_NDims)
enforce_geotype_geom - säkerställer att alla geometrier är av samma typ (se GeometryType)
enforce_srid_geom - säkerställer att varje geometri är i samma projektion (se ST_SRID)
Om en oid för tabellen anges försöker denna funktion fastställa srid, dimension och geometrityp för alla geometrikolumner i tabellen och lägger till begränsningar vid behov. Om det lyckas infogas en lämplig rad i tabellen geometry_columns, annars fångas undantaget upp och ett felmeddelande skickas ut som beskriver problemet.
Om oid för en vy anges, som med en tabell oid, försöker denna funktion bestämma srid, dimension och typ för alla geometrier i vyn och infogar lämpliga poster i tabellen geometry_columns, men ingenting görs för att upprätthålla begränsningar.
Den parameterlösa varianten är en enkel omslutning för den parameteriserade varianten som först trunkerar och fyller på geometry_columns-tabellen för varje spatial tabell och vy i databasen, och lägger till spatiala begränsningar i tabellerna där så är lämpligt. Den returnerar en sammanfattning av antalet geometrikolumner som upptäckts i databasen och det antal som infogats i tabellen geometry_columns. Den parametriserade versionen returnerar helt enkelt antalet rader som infogats i tabellen geometry_columns.
Tillgänglighet: 1.4.0
Ändrad: 2.0.0 Som standard används nu typmodifierare i stället för kontrollbegränsningar för att begränsa geometrityper. Du kan fortfarande använda check constraint-beteende istället genom att använda den nya use_typmod och ställa in den på false.
Förbättrad: 2.0.0 use_typmod valfritt argument introducerades som gör det möjligt att kontrollera om kolumner skapas med typmodifierare eller med kontrollbegränsningar.
This example populates geometry column metadata using typmod behavior. For this to work, there must be existing data.
CREATE TABLE public.myspatial_table(gid serial, geom geometry);
INSERT INTO myspatial_table(geom) VALUES(ST_GeomFromText('LINESTRING(1 2,3 4)', 4326) );
SELECT Populate_Geometry_Columns('public.myspatial_table'::regclass);1
Describe the table to see the typmod-based geometry column.
\d myspatial_table
Table "public.myspatial_table"
Columns:
gid integer not null default nextval('myspatial_table_gid_seq'::regclass)
geom geometry(LineString,4326)This example changes the geometry columns to use constraints if they are not typmod or already constrained. For this to work, there must be existing data.
CREATE TABLE public.myspatial_table_cs(gid serial, geom geometry);
INSERT INTO myspatial_table_cs(geom) VALUES(ST_GeomFromText('LINESTRING(1 2,3 4)', 4326) );
SELECT Populate_Geometry_Columns('public.myspatial_table_cs'::regclass, false);1
Describe the table to see the constraint-based geometry column.
\d myspatial_table_cs
Table "public.myspatial_table_cs"
Column | Type | Modifiers
--------+----------+------------------------------------------------------------------
gid | integer | not null default nextval('myspatial_table_cs_gid_seq'::regclass)
geom | geometry |
Check constraints:
"enforce_dims_geom" CHECK (st_ndims(geom) = 2)
"enforce_geotype_geom" CHECK (geometrytype(geom) = 'LINESTRING'::text OR geom IS NULL)
"enforce_srid_geom" CHECK (st_srid(geom) = 4326)UpdateGeometrySRID — Uppdaterar SRID för alla objekt i en geometrikolumn och metadata för tabellen.
text UpdateGeometrySRID(varchar table_name, varchar column_name, integer srid);
text UpdateGeometrySRID(varchar schema_name, varchar table_name, varchar column_name, integer srid);
text UpdateGeometrySRID(varchar catalog_name, varchar schema_name, varchar table_name, varchar column_name, integer srid);
Uppdaterar SRID för alla objekt i en geometrikolumn och uppdaterar begränsningar och referens i geometry_columns. Om kolumnen styrdes av en typdefinition kommer typdefinitionen att ändras. Observera: använder current_schema() på schemamedvetna pgsql-installationer om schema inte har angetts.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
Infoga geometrier i vägtabeller med en SRID-uppsättning som redan använder EWKT-format:
COPY roads (geom) FROM STDIN;
SRID=4326;LINESTRING(0 0, 10 10)
SRID=4326;LINESTRING(10 10, 15 0)
\.
Detta kommer att ändra srid för vägtabellen till 4326 från vad det var tidigare:
SELECT UpdateGeometrySRID('roads', 'geom', 4326);Det tidigare exemplet motsvarar denna DDL-sats:
ALTER TABLE roads ALTER COLUMN geom TYPE geometry(MULTILINESTRING, 4326) USING ST_SetSRID(geom, 4326);
Om du fick fel projektion (eller tog in den som okänd) i lasten och du ville omvandla till webbmercator allt på en gång kan du göra det med DDL men det finns ingen motsvarande PostGIS-hanteringsfunktion för att göra det på en gång.
ALTER TABLE roads ALTER COLUMN geom TYPE geometry(MULTILINESTRING, 3857) USING ST_Transform(ST_SetSRID(geom, 4326), 3857) ;
These functions instantiate new geometry or geography values. They assemble primitives, coordinate sequences, or existing geometries into well-formed spatial objects that can participate in subsequent analysis.
ST_Collect — Skapar en GeometryCollection eller Multi* geometri från en uppsättning geometrier.
geometry ST_Collect(geometry g1, geometry g2);
geometry ST_Collect(geometry[] g1_array);
geometry ST_Collect(geometry set g1field);
Samlar geometrier till en geometrisamling. Resultatet är antingen en Multi* eller en GeometryCollection, beroende på om indatageometrierna har samma eller olika typer (homogena eller heterogena). De ingående geometrierna lämnas oförändrade inom samlingen.
Variant 1: accepterar två inmatningsgeometrier
Variant 2: accepterar en array av geometrier
Variant 3: Aggregerad funktion som tar emot en rad med geometrier.
![]() | |
|
If any input geometry is a collection (Multi* or GeometryCollection), ST_Collect returns a GeometryCollection, since that is the only type which can contain nested collections. To prevent this, use ST_Dump in a subquery to expand input collections to their atomic elements (see example below).
Tillgänglighet: 1.4.0 - ST_Collect(geomarray) introducerades. ST_Collect förbättrades för att hantera fler geometrier snabbare.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
Two-input variant.
Samla 2D-punkter.
SELECT ST_Collect(
'POINT(1 2)',
'POINT(-2 3)' );MULTIPOINT((1 2),(-2 3))
Samla 3D-punkter.
SELECT ST_Collect(
'POINT(1 2 3)',
'POINT(1 2 4)' );MULTIPOINT(1 2 3,1 2 4)
Samla kurvor.
SELECT ST_Collect(
'CIRCULARSTRING(220268 150415,220227 150505,220227 150406)',
'CIRCULARSTRING(220227 150406,2220227 150407,220227 150406)');MULTICURVE(CIRCULARSTRING(220268 150415,220227 150505,220227 150406), CIRCULARSTRING(220227 150406,2220227 150407,220227 150406))
Array variant.
Använda en array constructor för en subquery.
SELECT ST_Collect(ARRAY(SELECT geom FROM sometable));
Använda en array constructor för värden.
SELECT ST_Collect(
ARRAY[ 'LINESTRING(1 2,3 4)'::geometry,
'LINESTRING(3 4,4 5)'::geometry ] ) As wktcollect;MULTILINESTRING((1 2,3 4),(3 4,4 5))
Aggregate variant.
Skapa flera samlingar genom att gruppera geometrier i en tabell.
SELECT stusps, ST_Collect(geom) AS geom FROM ( SELECT stusps, (ST_Dump(geom)).geom AS geom FROM somestatetable ) AS f GROUP BY stusps;
ST_LineFromMultiPoint — Skapar en LineString från en MultiPoint-geometri.
geometry ST_LineFromMultiPoint(geometry aMultiPoint);
Skapar en LineString från en MultiPoint-geometri.
Använd ST_MakeLine för att skapa linjer från Point- eller LineString-inmatningar.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Skapa en 3D-linestrings från en 3D MultiPoint
SELECT ST_LineFromMultiPoint('MULTIPOINT(1 2 3,4 5 6,7 8 9)');LINESTRING(1 2 3,4 5 6,7 8 9)
ST_MakeEnvelope — Skapar en rektangulär polygon från minimi- och maximikoordinater.
geometry ST_MakeEnvelope(float xmin, float ymin, float xmax, float ymax, integer srid=unknown);
Skapar en rektangulär polygon från minimi- och maximivärdena för X och Y. Inmatade värden måste vara i det spatiala referenssystem som anges av SRID. Om inget SRID anges används det okända spatiala referenssystemet (SRID 0).
Tillgänglighet: 1,5
Förbättrad: 2.0: Möjlighet att ange ett kuvert utan att ange en SRID infördes.
Building a bounding box polygon.
SELECT ST_MakeEnvelope(10, 10, 11, 11, 4326);
POLYGON((10 10, 10 11, 11 11, 11 10, 10 10))
ST_MakeLine — Skapar en LineString från Point-, MultiPoint- eller LineString-geometrier.
geometry ST_MakeLine(geometry geom1, geometry geom2);
geometry ST_MakeLine(geometry[] geoms_array);
geometry ST_MakeLine(geometry set geoms);
Skapar en LineString som innehåller punkterna i geometrierna Point, MultiPoint eller LineString. Andra geometrityper orsakar ett fel.
Variant 1: accepterar två inmatningsgeometrier
Variant 2: accepterar en array av geometrier
Variant 3: Aggregerad funktion som accepterar en rad med geometrier. För att säkerställa ordningen på geometrierna i indata, använd ORDER BY i funktionsanropet eller en underfråga med en ORDER BY-klausul.
Repeated nodes at the beginning of input LineStrings are collapsed to a single point. Repeated points in Point and MultiPoint inputs are not collapsed. Components of MultiLineString are handled in the order they appear in the collection. ST_RemoveRepeatedPoints can be used to collapse repeated points from the output LineString.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Availability: 3.7.0 - Support for MultiLineString input elements was introduced
Tillgänglighet: 2.3.0 - Stöd för MultiPoint-indataelement infördes
Tillgänglighet: 2.0.0 - Stöd för LineString-indataelement infördes
Tillgänglighet: 1.4.0 - ST_MakeLine(geomarray) introducerades. ST_MakeLine aggregatfunktioner förbättrades för att hantera fler punkter snabbare.
Two-input variant.
Skapa en linje som består av två punkter.
SELECT ST_MakeLine(ST_Point(1, 2), ST_Point(3, 4));
LINESTRING(1 2,3 4)
Skapa en 3D-linje från två 3D-punkter.
SELECT ST_MakeLine(ST_MakePoint(1, 2, 3), ST_MakePoint(3, 4, 5));
LINESTRING(1 2 3,3 4 5)
Skapa en linje från två åtskilda LineStrings.
SELECT ST_MakeLine('LINESTRING(0 0,1 1)', 'LINESTRING(2 2,3 3)');LINESTRING(0 0,1 1,2 2,3 3)
Array variant.
Skapa en rad från en matris som bildas av en underfråga med ordning.
SELECT ST_MakeLine(ARRAY(SELECT ST_Centroid(geom) FROM visit_locations ORDER BY visit_time));
Skapa en 3D-linje från en array av 3D-punkter
SELECT ST_MakeLine(ARRAY[ST_MakePoint(1, 2, 3), ST_MakePoint(3, 4, 5), ST_MakePoint(6, 6, 6)]);
LINESTRING(1 2 3,3 4 5,6 6 6)
Aggregate variant.
I detta exempel ställs frågor om tidsbaserade sekvenser av GPS-punkter från en uppsättning spår och en post skapas för varje spår. Resultatgeometrierna är LineStrings som består av GPS-spårpunkterna i den ordning de färdats.
Om du använder aggregatet ORDER BY får du en korrekt ordnad LineString.
SELECT gps.track_id, ST_MakeLine(gps.geom ORDER BY gps_time) AS geom FROM gps_points AS gps GROUP BY gps.track_id;
When ordering within the aggregate is not possible, ordering in a subquery can be used. However, sometimes the query plan may not respect the order of the subquery.
SELECT gps.track_id, ST_MakeLine(gps.geom) AS geom FROM ( SELECT track_id, gps_time, geom FROM gps_points ORDER BY track_id, gps_time ) AS gps GROUP BY gps.track_id;
ST_MakePoint — Skapar en 2D-, 3DZ- eller 4D-punkt.
geometry ST_MakePoint(float x, float y);
geometry ST_MakePoint(float x, float y, float z);
geometry ST_MakePoint(float x, float y, float z, float m);
Skapar en 2D XY-, 3D XYZ- eller 4D XYZM-punktgeometri. Använd ST_MakePointM för att skapa punkter med XYM-koordinater.
Använd ST_SetSRID för att ange en SRID för den skapade punkten.
ST_MakePoint är inte OGC-kompatibelt, men är snabbare än ST_GeomFromText och ST_PointFromText. Det är också lättare att använda för numeriska koordinatvärden.
![]() | |
För geodetiska koordinater är |
![]() | |
Funktionerna ST_Point, ST_PointZ, ST_PointM, och ST_PointZM kan användas för att skapa punkter med en given SRID. |
Denna funktion stöder 3d och kommer inte att tappa z-index.
This example creates a point with an unknown SRID.
SELECT ST_MakePoint(-71.1043443253471, 42.3150676015829);
This example creates a point in the WGS 84 geodetic CRS.
SELECT ST_SetSRID(ST_MakePoint(-71.1043443253471, 42.3150676015829), 4326);
This example creates a 3D point with altitude.
SELECT ST_MakePoint(1, 2, 1.5);
This example returns the Z coordinate of a point.
SELECT ST_Z(ST_MakePoint(1, 2, 1.5));
1.5
ST_MakePointM — Skapar en punkt från X-, Y- och M-värden.
geometry ST_MakePointM(float x, float y, float m);
Skapar en punkt med X-, Y- och M-ordinater (mått). Använd ST_MakePoint för att skapa punkter med XY-, XYZ- eller XYZM-koordinater.
Använd ST_SetSRID för att ange en SRID för den skapade punkten.
![]() | |
För geodetiska koordinater är |
![]() | |
Funktionerna ST_PointM, och ST_PointZM kan användas för att skapa punkter med ett M-värde och en given SRID. |
Skapa punkt med okänd SRID.
SELECT ST_MakePointM(-71.1043443253471, 42.3150676015829, 10);
POINTM(-71.1043443253471 42.3150676015829 10)
Skapa en punkt med ett mått i det geodetiska koordinatsystemet WGS 84.
SELECT ST_SetSRID(ST_MakePointM(-71.104, 42.315, 10), 4326);
SRID=4326;POINTM(-71.104 42.315 10)
Få mått på skapad punkt.
SELECT ST_M(ST_MakePointM(-71.104, 42.315, 10));
10
ST_MakePolygon — Creates a Polygon or CurvePolygon from a shell and optional list of holes.
geometry ST_MakePolygon(geometry linestring);
geometry ST_MakePolygon(geometry outerlinestring, geometry[] interiorlinestrings);
Creates a Polygon or CurvePolygon formed by the given shell and optional array of holes. Input geometries must be closed LineStrings, CircularStrings, CompoundCurves, or NURBSCurves (rings). If any input ring is curved, the result is a CurvePolygon.
Variant 1: Accepts one shell ring.
Variant 2: Accepts a shell ring and an array of inner (hole) rings. A geometry array can be constructed using the PostgreSQL array_agg(), ARRAY[] or ARRAY() constructs.
![]() | |
Denna funktion accepterar inte MultiLineStrings. Använd ST_LineMerge för att generera en LineString, eller ST_Dump för att extrahera LineStrings. |
Denna funktion stöder 3d och kommer inte att tappa z-index.
Enhanced: 3.7.0 - Support for curved input rings was introduced.
Single input variant.
Skapa en polygon från en 2D LineString.
SELECT ST_MakePolygon('LINESTRING(75 29,77 29,77 29,75 29)');Skapa en polygon från en öppen LineString och använd ST_StartPoint och ST_AddPoint för att stänga den.
SELECT ST_MakePolygon(ST_AddPoint(foo.open_line, ST_StartPoint(foo.open_line)) ) FROM ( SELECT 'LINESTRING(75 29,77 29,77 29,75 29)'::geometry As open_line) As foo;
Skapa en polygon från en 3D LineString
SELECT ST_MakePolygon('LINESTRING(75.15 29.53 1,77 29 1,77.6 29.5 1,75.15 29.53 1)');POLYGON((75.15 29.53 1,77 29 1,77.6 29.5 1,75.15 29.53 1))
Skapa en polygon från en LineString med mått
SELECT ST_MakePolygon('LINESTRINGM(75.15 29.53 1,77 29 1,77.6 29.5 2, 75.15 29.53 2)');POLYGONM((75.15 29.53 1,77 29 1,77.6 29.5 2,75.15 29.53 2))
Create a CurvePolygon from a CircularString shell.
SELECT ST_MakePolygon('CIRCULARSTRING(0 0,1 1,2 0,1 -1,0 0)');CURVEPOLYGON(CIRCULARSTRING(0 0,1 1,2 0,1 -1,0 0))
Outer shell with inner holes variant.
Skapa en munkpolygon med ett extra hål
SELECT ST_MakePolygon(
ST_ExteriorRing(ST_Buffer(ring.line, 10)),
ARRAY[ ST_Translate(ring.line, 1, 1),
ST_ExteriorRing(ST_Buffer(ST_Point(20, 20), 1)) ]
)
FROM (SELECT ST_ExteriorRing(ST_Buffer(ST_Point(10, 10), 10, 10)) AS line ) AS ring;
Skapa en uppsättning provinsgränser med hål som representerar sjöar. Indata är en tabell med provinspolygoner/multipolygoner och en tabell med vattenlinjesträckningar. Linjer som bildar sjöar bestäms med hjälp av ST_IsClosed. Provinsernas linjeföring extraheras med hjälp av ST_Boundary. Som krävs av ST_MakePolygon tvingas gränsen att vara en enda LineString med hjälp av ST_LineMerge. (Observera dock att om en provins har mer än en region eller har öar kommer detta att ge en ogiltig polygon) Genom att använda en LEFT JOIN säkerställs att alla provinser inkluderas även om de inte har några sjöar.
![]() | |
CASE construct används eftersom en null-array som skickas till ST_MakePolygon resulterar i ett NULL-returvärde. |
SELECT p.gid, p.province_name,
CASE
WHEN array_agg(w.geom) IS NULL THEN p.geom
ELSE ST_MakePolygon(
ST_LineMerge(ST_Boundary(p.geom)),
array_agg(w.geom)
)
END AS geom
FROM provinces p
LEFT JOIN waterlines w
ON ST_Within(w.geom, p.geom)
AND ST_IsClosed(w.geom)
GROUP BY p.gid, p.province_name, p.geom;
En annan teknik är att använda en korrelerad underfråga och ARRAY() constructor som omvandlar en raduppsättning till en array.
SELECT p.gid, p.province_name,
CASE
WHEN EXISTS (
SELECT w.geom
FROM waterlines w
WHERE ST_Within(w.geom, p.geom)
AND ST_IsClosed(w.geom)
)
THEN ST_MakePolygon(
ST_LineMerge(ST_Boundary(p.geom)),
ARRAY(
SELECT w.geom
FROM waterlines w
WHERE ST_Within(w.geom, p.geom)
AND ST_IsClosed(w.geom)
)
)
ELSE p.geom
END AS geom
FROM provinces p;
ST_Point — Skapar en punkt med X-, Y- och SRID-värden.
geometry ST_Point(float x, float y);
geometry ST_Point(float x, float y, integer srid=unknown);
Returnerar en Point med de angivna X- och Y-koordinatvärdena. Detta är SQL-MM:s motsvarighet till ST_MakePoint som bara tar X och Y.
![]() | |
För geodetiska koordinater är |
Förbättrad: 3.2.0 srid som ett extra valfritt argument har lagts till. Äldre installationer kräver att man kombinerar med ST_SetSRID för att markera srid på geometrin.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 6.1.2
Geometry.
SELECT ST_Point(-71.104, 42.315);
Skapar en punkt med SRID specificerad:
SELECT ST_Point(-71.104, 42.315, 4326);
Alternativt sätt att ange SRID:
SELECT ST_SetSRID(ST_Point(-71.104, 42.315), 4326);
Skapa geografiska punkter med hjälp av syntaxen :: cast:
SELECT ST_Point(-71.104, 42.315, 4326)::geography;
Kod före PostGIS 3.2, med hjälp av CAST:
SELECT CAST(ST_SetSRID(ST_Point(-71.104, 42.315), 4326) AS geography);
Om punktkoordinaterna inte är i ett geodetiskt koordinatsystem (t.ex. WGS84) måste de omprojiceras innan de kan läggas in i en geografi. I detta exempel projiceras en punkt i Pennsylvania State Plane feet (SRID 2273) till WGS84 (SRID 4326).
SELECT ST_Transform(ST_Point(3637510, 3014852, 2273), 4326)::geography;
ST_MakePoint, ST_PointZ, ST_PointM, ST_PointZM, ST_SetSRID, ST_Transform
ST_PointZ — Skapar en punkt med X-, Y-, Z- och SRID-värden.
geometry ST_PointZ(float x, float y, float z, integer srid=unknown);
Returnerar en Point med de angivna koordinatvärdena X, Y och Z, och eventuellt ett SRID-nummer.
Förbättrad: 3.2.0 srid som ett extra valfritt argument har lagts till. Äldre installationer kräver att man kombinerar med ST_SetSRID för att markera srid på geometrin.
SELECT ST_PointZ(-71.104, 42.315, 3.4, 4326)
SELECT ST_PointZ(-71.104, 42.315, 3.4, srid => 4326)
SELECT ST_PointZ(-71.104, 42.315, 3.4)
ST_PointM — Skapar en punkt med X-, Y-, M- och SRID-värden.
geometry ST_PointM(float x, float y, float m, integer srid=unknown);
Returnerar en Point med de angivna koordinatvärdena X, Y och M, och eventuellt ett SRID-nummer.
Förbättrad: 3.2.0 srid som ett extra valfritt argument har lagts till. Äldre installationer kräver att man kombinerar med ST_SetSRID för att markera srid på geometrin.
SELECT ST_PointM(-71.104, 42.315, 3.4, 4326)
SELECT ST_PointM(-71.104, 42.315, 3.4, srid => 4326)
SELECT ST_PointM(-71.104, 42.315, 3.4)
ST_PointZM — Skapar en punkt med X-, Y-, Z-, M- och SRID-värden.
geometry ST_PointZM(float x, float y, float z, float m, integer srid=unknown);
Returnerar en Point med de angivna koordinatvärdena X, Y, Z och M, och eventuellt ett SRID-nummer.
Förbättrad: 3.2.0 srid som ett extra valfritt argument har lagts till. Äldre installationer kräver att man kombinerar med ST_SetSRID för att markera srid på geometrin.
SELECT ST_PointZM(-71.104, 42.315, 3.4, 4.5, 4326)
SELECT ST_PointZM(-71.104, 42.315, 3.4, 4.5, srid => 4326)
SELECT ST_PointZM(-71.104, 42.315, 3.4, 4.5)
ST_Polygon — Skapar en polygon från en LineString med en angiven SRID.
geometry ST_Polygon(geometry lineString, integer srid);
Returnerar en polygon som byggts från den angivna LineString och anger det spatiala referenssystemet från srid.
ST_Polygon liknar ST_MakePolygon Variant 1 med tillägget att man kan ställa in SRID.
För att skapa polygoner med hål använder du ST_MakePolygon Variant 2 och sedan ST_SetSRID.
![]() | |
Denna funktion accepterar inte MultiLineStrings. Använd ST_LineMerge för att generera en LineString, eller ST_Dump för att extrahera LineStrings. |
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 8.3.2
Denna funktion stöder 3d och kommer inte att tappa z-index.
Skapa en 2D-polygon.
SELECT ST_Polygon('LINESTRING(75 29,77 29,77 31,75 31,75 29)'::geometry, 4326);POLYGON((75 29,77 29,77 31,75 31,75 29))
Skapa en 3D-polygon.
SELECT ST_Polygon('LINESTRING(75 29 1,77 29 2,77 31 2,75 31 1,75 29 1)'::geometry, 4326);SRID=4326;POLYGON((75 29 1,77 29 2,77 31 2,75 31 1,75 29 1))
ST_TileEnvelope — Skapar en rektangulär polygon i Web Mercator (SRID:3857) med hjälp av XYZ-plattsystemet.
geometry ST_TileEnvelope(integer tileZoom, integer tileX, integer tileY, geometry bounds=SRID=3857;LINESTRING(-20037508.342789 -20037508.342789,20037508.342789 20037508.342789), float margin=0.0);
Skapar en rektangulär polygon som motsvarar utsträckningen av en platta i XYZ-plattsystemet. Plattan specificeras av zoomnivån Z och XY-indexet för plattan i rutnätet på den nivån. Kan användas för att definiera de plattgränser som krävs av ST_AsMVTGeom för att konvertera geometri till MVT-koordinatrymden för plattan.
Som standard är plattans kuvert i koordinatsystemet Web Mercator (SRID:3857) med standardintervallet för systemet Web Mercator (-20037508.342789, 20037508.342789). Detta är det vanligaste koordinatsystemet som används för MVT-plattor. Den valfria parametern bounds kan användas för att generera plattor i vilket koordinatsystem som helst. Det är en geometri som har SRID och utsträckning för "Zoom Level zero"-kvadraten inom vilken XYZ-plattsystemet är inskrivet.
Den valfria marginalparametern kan användas för att expandera en platta med den angivna procentsatsen. T.ex. margin=0,125 expanderar plattan med 12,5%, vilket motsvarar buffer=512 när plattans storlek är 4096, som används i ST_AsMVTGeom. Detta är användbart för att skapa en plattbuffert för att inkludera data som ligger utanför plattans synliga område, men vars existens påverkar plattrenderingen. Ett stadsnamn (en punkt) kan t.ex. ligga nära kanten på en platta, så dess etikett bör återges på två plattor, även om punkten ligger i det synliga området på bara en platta. Om du använder expanderade plattor i en fråga kommer stadspunkten att inkluderas i båda plattorna. Använd ett negativt värde för att krympa plattan istället. Värden mindre än -0,5 är förbjudna eftersom det skulle eliminera plattan helt. Ange inte en marginal när du använder ST_AsMVTGeom. Se exemplet för ST_AsMVT.
Förbättrad: 3.1.0 Lagt till marginalparameter.
Tillgänglighet: 3.0.0
Show tile (2, 1, 1) within the root tile (0, 0, 0).
SELECT ST_TileEnvelope(0, 0, 0) AS input_z0_x0_y0, ST_TileEnvelope(2, 1, 1) AS z2_x1_y1;
input_z0_x0_y0 | z2_x1_y1 ----------------+----------- POLYGON((-20037508.342789244 -20037508.342789244,-20037508.342789244 20037508.342789244,20037508.342789244 20037508.342789244,20037508.342789244 -20037508.342789244,-20037508.342789244 -20037508.342789244)) | POLYGON((-10018754.171394622 0,-10018754.171394622 10018754.171394622,0 10018754.171394622,0 0,-10018754.171394622 0))
SELECT ST_TileEnvelope(3, 1, 1, ST_MakeEnvelope(-180, -90, 180, 90, 4326));
POLYGON((-135 45,-135 67.5,-90 67.5,-90 45,-135 45))
ST_HexagonGrid — Returnerar en uppsättning hexagoner och cellindex som helt täcker gränserna för geometriargumentet.
setof record ST_HexagonGrid(float8 size, geometry bounds);
Starts with the concept of a hexagon tiling of the plane. (Not a hexagon tiling of the globe; for H3 use the h3-pg extension.) For a given planar SRS, and a given edge size, starting at the origin of the SRS, there is one unique hexagonal tiling of the plane, Tiling(SRS, Size). This function answers the question: what hexagons in a given Tiling(SRS, Size) overlap with a given bounds.

SRS för utdatahexagonerna är den SRS som tillhandahålls av begränsningsgeometrin.
Om man dubblar eller tripplar hexagonens kantstorlek genereras en ny parent tiling som passar med origin tilingen. Tyvärr är det inte möjligt att generera överordnade hexagonbeläggningar som barnbeläggningarna passar perfekt i.
Tillgänglighet: 3.1.0
Unit hexagons covering rectangular bounds.
WITH bounds AS (
SELECT ST_MakeEnvelope(2, 1, 4, 3, 3857) AS geom
), grid AS (
SELECT hex.*
FROM bounds
CROSS JOIN LATERAL ST_HexagonGrid(1, geom) AS hex
)
SELECT (SELECT geom FROM bounds) AS input_bounds,
ST_Collect(geom ORDER BY i, j) AS grid
FROM grid;POLYGON((2 1,2 3,4 3,4 1,2 1)) | MULTIPOLYGON(((0.5 0.866,1 0,2 0,2.5 0.866,2 1.732,1 1.732,0.5 0.866)),((0.5 2.598,1 1.732,2 1.732,2.5 2.598,2 3.464,1 3.464,0.5 2.598)),((2 1.732,2.5 0.866,3.5 0.866,4 1.732,3.5 2.598,2.5 2.598,2 1.732)),((2 3.464,2.5 2.598,3.5 2.598,4 3.464,3.5 4.33,2.5 4.33,2 3.464)),((3.5 0.866,4 0,5 0,5.5 0.866,5 1.732,4 1.732,3.5 0.866)),((3.5 2.598,4 1.732,5 1.732,5.5 2.598,5 3.464,4 3.464,3.5 2.598)))
Child tiles that intersect a doubled-size parent hexagon share the tiling origin, but do not nest perfectly inside the parent.
WITH parent AS (
SELECT ST_Hexagon(2, 0, 0) AS geom
), children AS (
SELECT child.*
FROM parent
CROSS JOIN LATERAL ST_HexagonGrid(1, geom) AS child
WHERE ST_Area(ST_Intersection(child.geom, parent.geom)) > 0
)
SELECT ST_Collect(geom ORDER BY i, j) AS children,
(SELECT geom FROM parent) AS parent
FROM children;MULTIPOLYGON(((-2.5 -0.866,-2 -1.732,-1 -1.732,-0.5 -0.866,-1 0,-2 0,-2.5 -0.866)),((-2.5 0.866,-2 0,-1 0,-0.5 0.866,-1 1.732,-2 1.732,-2.5 0.866)),((-1 -1.732,-0.5 -2.598,0.5 -2.598,1 -1.732,0.5 -0.866,-0.5 -0.866,-1 -1.732)),((-1 0,-0.5 -0.866,0.5 -0.866,1 0,0.5 0.866,-0.5 0.866,-1 0)),((-1 1.732,-0.5 0.866,0.5 0.866,1 1.732,0.5 2.598,-0.5 2.598,-1 1.732)),((0.5 -0.866,1 -1.732,2 -1.732,2.5 -0.866,2 0,1 0,0.5 -0.866)),((0.5 0.866,1 0,2 0,2.5 0.866,2 1.732,1 1.732,0.5 0.866))) | POLYGON((-2 0,-1 -1.732,1 -1.732,2 0,1 1.732,-1 1.732,-2 0))
Counting points in hexagons.
För att göra en punktsammanfattning mot ett hexagonalt rutnät genererar du ett hexagonalt rutnät med punkternas utsträckning som gränser och ansluter sedan spatialt till det rutnätet.
SELECT COUNT(*), hexes.geom
FROM ST_HexagonGrid(
10000,
ST_SetSRID(ST_EstimatedExtent('pointtable', 'geom'), 3857)
) AS hexes
INNER JOIN pointtable AS pts
ON ST_Intersects(pts.geom, hexes.geom)
GROUP BY hexes.geom;Generating hex coverage of polygons.
If a grid is generated for each polygon boundary and filtered to intersecting cells, adjacent regions receive overlapping hexagons along their shared border. The build-time figure below uses two simple regions in place of an external administrative-boundary table, so the example is self-contained.

WITH admin1(gid, geom) AS (
VALUES
(1, ST_MakeEnvelope(0, 0, 3, 3, 3857)),
(2, ST_MakeEnvelope(3, 0, 6, 3, 3857))
), coverage AS (
SELECT hex.i, hex.j, hex.geom
FROM admin1
CROSS JOIN LATERAL ST_HexagonGrid(1.5, admin1.geom) AS hex
WHERE ST_Intersects(admin1.geom, hex.geom)
GROUP BY hex.i, hex.j, hex.geom
), layers AS (
SELECT 'region' AS kind, gid AS position, geom
FROM admin1
UNION ALL
SELECT
'hexagon',
1000 + row_number() OVER (ORDER BY i, j),
geom
FROM coverage
)
SELECT
CASE kind WHEN 'region' THEN geom END AS input_region,
CASE kind WHEN 'hexagon' THEN geom END AS hexagon
FROM layers
ORDER BY position;POLYGON((0 0,0 3,3 3,3 0,0 0)) | null POLYGON((3 0,3 3,6 3,6 0,3 0)) | null null | POLYGON((-1.5 0,-0.75 -1.3,0.75 -1.3,1.5 0,0.75 1.3,-0.75 1.3,-1.5 0)) null | POLYGON((-1.5 2.6,-0.75 1.3,0.75 1.3,1.5 2.6,0.75 3.9,-0.75 3.9,-1.5 2.6)) null | POLYGON((0.75 1.3,1.5 0,3 0,3.75 1.3,3 2.6,1.5 2.6,0.75 1.3)) null | POLYGON((0.75 3.9,1.5 2.6,3 2.6,3.75 3.9,3 5.2,1.5 5.2,0.75 3.9)) null | POLYGON((3 0,3.75 -1.3,5.25 -1.3,6 0,5.25 1.3,3.75 1.3,3 0)) null | POLYGON((3 2.6,3.75 1.3,5.25 1.3,6 2.6,5.25 3.9,3.75 3.9,3 2.6)) null | POLYGON((5.25 1.3,6 0,7.5 0,8.25 1.3,7.5 2.6,6 2.6,5.25 1.3)) null | POLYGON((5.25 3.9,6 2.6,7.5 2.6,8.25 3.9,7.5 5.2,6 5.2,5.25 3.9))
The same pattern applies to a real administrative-boundary table:
![]() | |
Nyckelordet LATERAL är underförstått för set-returning-funktioner när man hänvisar till en tidigare tabell i FROM-listan. Så CROSS JOIN LATERAL, CROSS JOIN eller helt enkelt , är likvärdiga constructs för det här exemplet. |
SELECT admin1.gid, hex.geom
FROM
admin1
CROSS JOIN
ST_HexagonGrid(100000, admin1.geom) AS hex
WHERE
adm0_a3 = 'USA'
AND
ST_Intersects(admin1.geom, hex.geom)ST_Hexagon — Returnerar en enda hexagon med den angivna kantstorleken och cellkoordinaten inom hexagonens rutnätsutrymme.
geometry ST_Hexagon(float8 size, integer cell_i, integer cell_j, geometry origin);
Använder samma hexagontilingkoncept som ST_HexagonGrid, men genererar bara en hexagon vid önskad cellkoordinat. Eventuellt kan du justera ursprungskoordinaten för kaklet, standardkoordinaten är 0,0.
Hexagoner genereras utan att någon SRID har angetts, så använd ST_SetSRID för att ange den SRID du förväntar dig.
Tillgänglighet: 3.1.0
Creating a hexagon at the origin.
SELECT ST_SetSRID(ST_Hexagon(1.0, 0, 0), 3857);
POLYGON((-1 0,-0.5 -0.8660254037844387,0.5 -0.8660254037844387,1 0,0.5 0.8660254037844387,-0.5 0.8660254037844387,-1 0))
ST_SquareGrid — Returnerar en uppsättning rutnätsrutor och cellindex som helt täcker gränserna för geometriargumentet.
setof record ST_SquareGrid(float8 size, geometry bounds);
Börjar med konceptet av en kvadratisk tiling av planet. För en given plan SRS och en given kantstorlek, med början vid SRS:ens ursprung, finns det en unik kvadratisk tiling av planet, Tiling(SRS, Size). Denna funktion svarar på frågan: vilka rutnät i en given Tiling(SRS, Size) överlappar med en given gräns.
SRS för utdatarutorna är den SRS som tillhandahålls av avgränsningsgeometrin.
Dubblering eller kantstorlek av kvadraten genererar en ny överordnad tiling som passar perfekt med den ursprungliga tilingen. Vanliga webbkartor i mercator är bara tvåpotenser av två kvadratiska rutnät i mercatorplanet.
Tillgänglighet: 3.1.0
Generating a 1 degree grid for a country.
Rutnätet kommer att fylla hela landets gränser, så om du bara vill ha rutor som berör landet måste du filtrera efteråt med ST_Intersects.
WITH grid AS ( SELECT (ST_SquareGrid(1, ST_Transform(geom, 4326))).* FROM admin0 WHERE name = 'Canada' ) SELEcT geom FROM grid
Counting points in squares (using single chopped grid).
För att göra en punktsammanfattning mot en kvadratisk platta, generera ett kvadratiskt rutnät med hjälp av punkternas utsträckning som gränser och sedan spatialt ansluta till det rutnätet. Observera att den beräknade omfattningen kan skilja sig från den faktiska omfattningen, så var försiktig och se åtminstone till att du har analyserat din tabell.
SELECT COUNT(*), squares.geom
FROM pointtable AS pts
INNER JOIN ST_SquareGrid(
1000,
ST_SetSRID(ST_EstimatedExtent('pointtable', 'geom'), 3857)
) AS squares
ON ST_Intersects(pts.geom, squares.geom)
GROUP BY squares.geom;Counting points in squares using set of grid per point.
Detta ger samma resultat som i det första exemplet, men blir långsammare för ett stort antal punkter
SELECT COUNT(*), squares.geom FROM pointtable AS pts INNER JOIN ST_SquareGrid( 1000, pts.geom ) AS squares ON ST_Intersects(pts.geom, squares.geom) GROUP BY squares.geom;
ST_Square — Returnerar en enda kvadrat med hjälp av den angivna kantstorleken och cellkoordinaten inom kvadratens rutnätsutrymme.
geometry ST_Square(float8 size, integer cell_i, integer cell_j, geometry origin='POINT(0 0)');
Använder samma koncept med kvadratiska plattor som ST_SquareGrid, men genererar bara en kvadrat i önskad cellkoordinat. Eventuellt kan du justera ursprungskoordinaten för kaklet, standardkoordinaten är 0,0.
Kvadrater genereras med SRID för det givna ursprunget. Använd ST_SetSRID för att ställa in SRID om det angivna ursprunget har ett okänt SRID (vilket är fallet som standard).
Tillgänglighet: 3.1.0
Creating a square at the origin.
SELECT ST_SetSRID(ST_Square(1.0, 0, 0), 3857);
st_astext ------------------------------------- POLYGON((0 0,0 1,1 1,1 0,0 0)) (1 row)
ST_Letters — Returnerar inmatade bokstäver som återges som geometri med en standardstartposition vid origo och en standardtexthöjd på 100.
geometry ST_Letters(text letters, json font);
Använder ett inbyggt teckensnitt för att rendera en sträng som en multipolygongeometri. Standardhöjden för texten är 100,0, avståndet från botten av en nedåtriktad bokstav till toppen av en stor bokstav. Standardstartpositionen placerar början av baslinjen vid origo. Att åsidosätta teckensnittet innebär att en json-karta skickas in, med ett tecken som nyckel och base64-kodade TWKB för teckensnittsformen, med teckensnitt som har en höjd på 1000 enheter från botten av de nedåtgående till toppen av de stora bokstäverna.
Texten genereras som standard i origo, så för att flytta och ändra storlek på texten måste du först använda funktionen ST_Scale och sedan funktionen ST_Translate.
Tillgänglighet: 3.3.0
Generating the word 'Yo'.
SELECT ST_Letters('Yo');MULTIPOLYGON(((34.5 73.8,54 73.8,53.1 72.9,35.1 28.7,35.1 0.9,36 0,18 0,19 0.9,19 28.7,0.9 72.9,0 73.8,19.5 73.8,18.6 72.9,23 61.6,27 47.4,31.1 61.9,35.4 72.9,34.5 73.8)),((68.87 58,69.97 58,71.07 57.9,72.17 57.8,73.17 57.7,74.27 57.5,75.27 57.3,76.17 57.1,77.17 56.8,78.07 56.5,78.97 56.1,79.87 55.7,80.67 55.3,81.47 54.8,82.27 54.3,82.97 53.7,83.67 53.1,84.37 52.5,84.97 51.8,85.57 51.1,86.07 50.3,86.57 49.5,87.07 48.7,87.57 47.9,87.97 47,88.37 46.1,88.67 45.1,88.97 44.1,89.17 43.1,89.37 42.1,89.47 41,89.57 39.9,89.57 38.7,89.57 18.9,89.57 17.7,89.47 16.6,89.37 15.5,89.17 14.5,88.97 13.5,88.77 12.5,88.47 11.5,88.07 10.6,87.67 9.7,87.27 8.9,86.77 8.1,86.27 7.3,85.67 6.6,85.07 5.9,84.47 5.2,83.77 4.6,83.07 4,82.27 3.5,81.57 2.9,80.77 2.5,79.87 2,79.07 1.6,78.17 1.2,77.27 0.8,76.37 0.5,75.37 0.2,74.37 0,73.37 -0.2,72.27 -0.4,71.17 -0.5,70.07 -0.5,68.97 -0.5,67.87 -0.5,66.77 -0.4,65.67 -0.3,64.57 -0.2,63.57 0,62.57 0.2,61.57 0.5,60.57 0.8,59.67 1.1,58.77 1.5,57.87 1.9,57.07 2.4,56.27 2.9,55.47 3.4,54.77 3.9,54.07 4.5,53.37 5.1,52.77 5.8,52.17 6.5,51.67 7.2,51.17 8,50.67 8.8,50.17 9.7,49.77 10.6,49.37 11.5,49.07 12.5,48.77 13.5,48.57 14.5,48.37 15.6,48.27 16.7,48.17 17.8,48.17 18.9,48.17 38.7,48.17 39.9,48.27 41,48.37 42.1,48.57 43.1,48.77 44.1,48.97 45.1,49.27 46.1,49.67 47,50.07 47.9,50.47 48.7,50.97 49.5,51.47 50.3,52.07 51,52.67 51.7,53.27 52.4,53.97 53,54.67 53.6,55.47 54.1,56.17 54.6,57.07 55.1,57.87 55.6,58.77 56,59.67 56.4,60.57 56.7,61.57 57,62.47 57.3,63.47 57.5,64.57 57.7,65.57 57.8,66.67 57.9,67.77 58,68.87 58),(73.77 38.9,72.27 41.6,68.97 42.6,65.57 41.7,64.07 38.9,64.07 18.9,65.47 16.2,68.77 15.2,72.07 16.1,73.77 18.9,73.77 38.9)))
Generating the word 'PostGIS'.
SELECT ST_Letters('PostGIS') AS letters;MULTIPOLYGON(((43 39,43 38,42 37,42 36,42 35,42 34,42 33,42 32,41 31,41 30,40 29,40 28,39 28,39 27,38 26,38 26,37 25,36 24,36 24,35 24,34 23,33 23,33 22,32 22,31 22,30 21,29 21,28 21,27 21,26 20,25 20,24 20,23 20,17 20,17 1,18 0,0 0,1 1,1 73,0 74,23 74,24 74,25 74,26 74,27 74,28 73,29 73,30 73,31 73,32 72,33 72,33 72,34 72,35 71,36 70,36 70,37 69,38 69,38 68,39 67,39 67,40 66,40 65,41 64,41 64,42 63,42 62,42 61,42 60,42 58,42 57,43 56,43 55,43 39),(26 56,26 58,23 59,17 59,17 35,23 35,26 36,26 38,26 56)),((69 58,70 58,71 58,72 58,73 58,74 58,75 57,76 57,77 57,78 56,79 56,80 56,81 55,82 55,82 54,83 54,84 53,85 52,85 52,86 51,86 50,87 50,87 49,88 48,88 47,89 46,89 45,89 44,89 43,90 42,90 41,90 40,90 39,90 19,90 18,90 17,90 16,89 14,89 14,89 12,89 12,88 11,88 10,87 9,87 8,86 7,86 7,85 6,85 5,84 5,83 4,82 4,82 3,81 2,80 2,79 2,78 1,77 1,77 0,76 0,75 0,74 0,72 0,71 0,70 0,69 0,68 0,67 0,66 0,65 0,64 0,63 0,62 0,61 1,60 1,59 2,58 2,57 2,56 3,56 3,55 4,54 4,54 5,53 6,52 6,52 7,51 8,51 9,50 10,50 11,50 12,49 12,49 14,49 14,49 16,48 17,48 18,48 19,48 39,48 40,48 41,49 42,49 43,49 44,49 45,49 46,50 47,50 48,51 49,51 50,52 50,52 51,53 52,53 52,54 53,55 54,56 54,56 55,57 55,58 56,59 56,60 56,61 57,62 57,63 57,64 58,65 58,66 58,67 58,68 58,69 58),(74 39,72 42,69 43,66 42,64 39,64 19,66 16,69 15,72 16,74 19,74 39)),((111 38,112 37,112 37,113 37,113 37,114 36,115 36,116 36,116 36,117 35,118 35,119 34,120 34,121 33,121 33,122 32,123 32,124 31,125 30,126 30,126 29,127 28,128 27,128 27,129 26,129 25,130 24,130 23,131 22,131 21,131 20,131 18,131 17,131 16,131 15,131 14,130 12,130 11,130 10,129 9,129 8,128 8,128 7,127 6,127 5,126 5,126 4,125 3,124 3,124 2,123 2,122 1,121 1,120 1,120 0,119 0,118 0,117 0,116 0,115 0,114 0,113 0,112 0,111 0,110 0,110 0,109 0,108 0,107 0,106 0,105 0,104 0,103 0,102 1,101 1,100 1,99 2,97 2,96 3,95 3,94 4,99 19,99 19,100 18,100 18,100 18,101 18,101 18,102 18,102 18,103 17,103 17,104 17,104 17,105 17,105 17,106 16,106 16,107 16,107 16,108 16,108 16,109 16,110 16,110 16,111 16,111 16,112 15,112 15,113 15,113 15,113 15,114 15,114 15,115 16,115 16,115 17,115 17,115 18,115 18,115 19,115 19,115 20,114 20,114 20,113 20,113 20,113 20,112 20,112 21,111 21,111 21,110 21,109 22,109 22,108 22,108 22,107 23,107 23,106 24,106 24,105 24,104 24,104 25,103 25,103 26,102 26,102 26,101 27,101 28,100 28,100 28,99 29,99 30,98 30,98 31,98 31,97 32,97 33,97 33,96 34,96 35,96 35,96 36,96 37,96 38,96 38,95 39,95 40,95 41,96 42,96 43,96 43,96 44,96 45,96 45,96 46,97 47,97 47,97 48,97 48,97 49,98 49,98 50,98 50,99 51,99 51,99 52,100 52,100 52,100 53,101 53,101 53,101 54,101 54,102 54,102 54,102 55,103 55,103 55,103 55,104 56,105 56,106 56,106 57,107 57,108 57,109 58,110 58,111 58,112 58,113 58,114 58,115 58,116 58,117 58,118 58,118 58,119 58,120 58,121 57,122 57,123 57,123 57,124 56,125 56,126 56,126 56,127 56,127 55,128 55,128 55,129 55,129 55,123 40,123 40,122 40,122 40,122 40,122 40,121 40,121 40,121 41,120 41,120 41,119 41,119 41,119 41,118 41,118 41,118 41,117 41,117 41,117 42,116 42,116 42,115 42,115 42,115 42,114 42,114 42,114 42,113 42,113 42,113 42,112 42,112 42,112 42,112 42,112 42,112 42,112 42,112 42,112 42,111 42,111 42,111 41,111 41,111 41,111 41,111 41,111 40,111 40,111 40,111 40,111 40,111 40,111 39,111 39,111 39,111 39,111 39,111 38,111 38,111 38,111 38,111 38,111 38,111 38)),((161 15,166 15,167 16,167 -1,166 0,160 0,160 0,159 0,158 0,157 0,157 0,156 0,155 0,155 0,154 0,153 0,153 1,152 1,151 1,151 1,150 2,149 2,149 2,148 3,147 3,147 4,146 4,146 5,145 5,145 6,144 6,144 7,143 8,143 9,142 10,142 10,141 11,141 12,141 43,136 43,135 42,135 59,136 58,141 58,141 74,140 75,158 75,157 74,157 58,165 58,166 59,166 42,165 43,157 43,157 18,157 17,157 17,157 17,158 17,158 16,158 16,158 16,159 16,159 16,159 16,160 16,160 15,160 15,161 15,161 15,161 15)),((214 13,214 12,213 12,213 11,213 10,212 10,212 9,212 8,211 8,211 7,210 6,210 6,209 5,209 5,208 4,208 4,207 3,206 3,206 2,205 2,204 2,203 1,203 1,202 0,201 0,200 0,199 0,199 0,198 0,197 0,196 -1,195 -1,194 -1,193 -1,192 -1,190 0,189 0,188 0,187 0,186 0,185 1,184 1,183 1,182 2,182 2,181 3,180 3,179 4,178 4,178 5,177 6,176 6,176 7,175 8,175 9,175 10,174 10,174 11,174 12,173 13,173 14,173 15,173 16,173 18,173 19,173 54,173 56,173 56,173 57,173 58,173 59,173 60,173 61,174 62,174 63,174 64,174 64,175 65,175 66,176 67,176 68,177 68,177 69,178 70,179 70,179 71,180 71,181 72,182 72,183 72,184 73,185 73,186 73,187 74,188 74,189 74,190 74,192 74,210 74,210 58,192 58,191 58,191 58,191 58,190 58,190 58,190 58,190 57,189 57,189 57,189 56,189 56,189 56,189 56,189 55,189 55,189 54,189 19,189 19,189 18,189 18,189 18,189 17,189 17,189 17,190 17,190 16,190 16,191 16,191 16,191 16,192 15,192 15,193 15,193 15,193 15,194 15,194 15,195 15,195 15,196 15,196 15,196 15,197 15,197 15,198 16,198 16,198 16,199 16,199 16,199 32,193 32,193 46,214 46,214 13)),((236 73,236 1,237 0,219 0,220 1,220 73,219 74,237 74,236 73)),((264 45,265 45,266 44,266 44,267 44,268 43,269 43,270 42,271 42,272 42,273 41,274 40,274 40,275 39,276 39,277 38,277 38,278 37,279 36,279 35,280 35,280 34,281 33,281 32,282 31,282 30,283 29,283 28,283 27,283 26,284 25,284 24,284 22,283 21,283 20,283 20,283 19,283 18,283 17,283 16,283 15,282 15,282 14,282 13,282 13,281 12,281 11,281 11,280 10,280 10,280 9,279 9,279 8,279 8,278 7,278 7,278 6,277 6,277 6,276 5,276 5,276 5,275 4,275 4,275 4,274 3,273 3,272 2,271 2,270 1,269 1,268 1,267 0,266 0,264 0,263 0,262 0,261 0,260 0,259 0,258 0,257 0,256 0,255 0,253 0,252 0,251 1,250 1,249 2,248 2,247 2,246 3,245 3,244 4,243 4,242 4,242 5,246 21,247 20,248 20,248 20,249 20,250 19,251 19,251 19,252 18,253 18,254 18,255 18,255 17,256 17,257 17,258 17,259 17,259 16,260 16,261 16,262 16,262 17,263 17,264 17,264 17,265 17,265 18,266 18,266 19,267 19,267 20,267 21,267 22,267 22,267 23,267 23,267 24,267 24,267 24,267 25,266 25,266 26,265 26,265 26,264 27,264 27,263 28,262 28,261 28,261 29,260 29,259 30,258 30,258 30,257 31,256 31,255 32,254 32,253 33,253 33,252 34,251 34,250 35,249 36,248 36,248 37,247 38,246 39,246 39,245 40,244 41,244 42,244 43,243 44,243 45,243 46,242 47,242 49,242 50,242 51,242 53,242 55,242 56,242 58,243 60,243 61,244 62,245 64,246 65,247 66,248 67,249 68,250 69,251 70,252 71,253 72,255 72,256 73,258 73,259 74,261 74,262 74,264 74,265 74,267 74,269 74,270 74,272 73,274 73,275 73,277 72,279 72,280 71,275 56,275 57,274 57,274 57,273 57,273 57,272 57,271 58,271 58,270 58,269 58,269 58,268 58,267 58,267 58,266 58,265 58,265 58,264 58,263 58,263 58,262 58,262 58,261 57,260 57,260 56,260 56,259 56,259 55,258 54,258 54,258 53,258 52,258 52,258 51,258 51,258 50,258 50,259 49,259 48,259 48,260 48,260 47,261 47,262 46,262 46,263 46,263 45,264 45)))
Scaling and moving words.
WITH letters AS (
SELECT ST_Letters('Yo') AS geom
)
SELECT geom AS input_letters,
ST_Translate(ST_Scale(geom, 2, 2), 120, 0)
AS scaled_letters
FROM letters;MULTIPOLYGON(((34 74,54 74,53 73,35 29,35 1,36 0,18 0,19 1,19 29,1 73,0 74,20 74,19 73,23 62,27 47,31 62,35 73,34 74)),((69 58,70 58,71 58,72 58,73 58,74 58,75 57,76 57,77 57,78 56,79 56,80 56,81 55,81 55,82 54,83 54,84 53,84 52,85 52,86 51,86 50,87 50,87 49,88 48,88 47,88 46,89 45,89 44,89 43,89 42,89 41,90 40,90 39,90 19,90 18,89 17,89 16,89 14,89 14,89 12,88 12,88 11,88 10,87 9,87 8,86 7,86 7,85 6,84 5,84 5,83 4,82 4,82 3,81 2,80 2,79 2,78 1,77 1,76 0,75 0,74 0,73 0,72 0,71 0,70 0,69 0,68 0,67 0,66 0,65 0,64 0,63 0,62 0,61 1,60 1,59 2,58 2,57 2,56 3,55 3,55 4,54 4,53 5,53 6,52 6,52 7,51 8,51 9,50 10,50 11,49 12,49 12,49 14,49 14,48 16,48 17,48 18,48 19,48 39,48 40,48 41,48 42,49 43,49 44,49 45,49 46,50 47,50 48,50 49,51 50,51 50,52 51,53 52,53 52,54 53,55 54,55 54,56 55,57 55,58 56,59 56,60 56,61 57,62 57,62 57,63 58,65 58,66 58,67 58,68 58,69 58),(74 39,72 42,69 43,66 42,64 39,64 19,65 16,69 15,72 16,74 19,74 39))) | MULTIPOLYGON(((189 148,228 148,226 146,190 57,190 2,192 0,156 0,158 2,158 57,122 146,120 148,159 148,157 146,166 123,174 95,182 124,191 146,189 148)),((258 116,260 116,262 116,264 116,266 115,269 115,271 115,272 114,274 114,276 113,278 112,280 111,281 111,283 110,285 109,286 107,287 106,289 105,290 104,291 102,292 101,293 99,294 97,295 96,296 94,297 92,297 90,298 88,298 86,299 84,299 82,299 80,299 77,299 38,299 35,299 33,299 31,298 29,298 27,298 25,297 23,296 21,295 19,295 18,294 16,293 15,291 13,290 12,289 10,288 9,286 8,285 7,283 6,282 5,280 4,278 3,276 2,275 2,273 1,271 0,269 0,267 0,265 -1,262 -1,260 -1,258 -1,256 -1,254 -1,251 -1,249 0,247 0,245 0,243 1,241 2,239 2,238 3,236 4,234 5,233 6,231 7,230 8,228 9,227 10,226 12,224 13,223 14,222 16,221 18,220 19,220 21,219 23,218 25,218 27,217 29,217 31,217 33,216 36,216 38,216 77,216 80,217 82,217 84,217 86,218 88,218 90,219 92,219 94,220 96,221 97,222 99,223 101,224 102,225 103,227 105,228 106,229 107,231 108,232 109,234 110,236 111,238 112,239 113,241 113,243 114,245 115,247 115,249 115,251 116,253 116,256 116,258 116),(268 78,265 83,258 85,251 83,248 78,248 38,251 32,258 30,264 32,268 38,268 78)))
ST_MakeNurbsCurve — Creates a NURBS (Non-Uniform Rational B-Spline) curve from control points, optional weights, and optional knot vector.
geometry ST_MakeNurbsCurve(integer degree, geometry control_points, float8[] weights, float8[] knots);
Creates a NURBS (Non-Uniform Rational B-Spline) curve geometry from the specified parameters. NURBS curves are smooth parametric curves that provide precise control over curve shape through control points, weights, and knot values.
The degree parameter specifies the polynomial degree of the curve (must be between 1 and 10). Higher degrees produce smoother curves.
The control_points must be a LINESTRING geometry defining the control polygon. The number of control points must be at least degree + 1.
The optional weights array assigns a weight to each control point. All weights must be positive. If NULL or omitted, uniform weights (1.0) are used, resulting in a non-rational B-spline.
The optional knots array defines the parameter space. If NULL or omitted, a uniform clamped knot vector is automatically generated. If provided, the knot vector must have exactly (npoints + degree + 1) elements and must be non-decreasing.
Availability: 3.7.0
This example creates a degree-2 NURBS curve with uniform weights.
SELECT ST_MakeNurbsCurve(
2,
'LINESTRING(0 0,5 10,10 0)'::geometry
);NURBSCURVE(DEGREE 2, CONTROLPOINTS(NURBSPOINT(WEIGHTEDPOINT(0 0),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT(5 10),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT(10 0),WEIGHT 1)),KNOTS (KNOT(0,3), KNOT(1,3)))
This example creates a rational NURBS curve with custom weights.
SELECT ST_MakeNurbsCurve(
2,
'LINESTRING(0 0,5 10,10 0)'::geometry,
ARRAY[1.0, 2.0, 1.0]
);NURBSCURVE(DEGREE 2, CONTROLPOINTS(NURBSPOINT(WEIGHTEDPOINT(0 0),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT(5 10),WEIGHT 2), NURBSPOINT(WEIGHTEDPOINT(10 0),WEIGHT 1)),KNOTS (KNOT(0,3), KNOT(1,3)))
This example creates a NURBS curve with a non-uniform knot vector.
SELECT ST_MakeNurbsCurve(
2,
'LINESTRING(0 0,3 10,7 10,10 0)'::geometry,
ARRAY[1.0, 1.0, 1.0, 1.0],
ARRAY[0.0, 0.0, 0.0, 0.3, 1.0, 1.0, 1.0]
);NURBSCURVE(DEGREE 2, CONTROLPOINTS(NURBSPOINT(WEIGHTEDPOINT(0 0),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT(3 10),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT(7 10),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT(10 0),WEIGHT 1)),KNOTS (KNOT(0,3), KNOT(0.3,1), KNOT(1,3)))
These functions expose structural information about an existing geometry without changing it. They provide access to metadata such as geometry type, dimensionality, or coordinate components so that spatial expressions can interrogate complex objects in a controlled way.
geometry_dump-rader för komponenterna i en geometri.geometry_dump-rader för koordinaterna i en geometri.geometry_dump-rader för segmenten i en geometri.geometry_dump-rader för de yttre och inre ringarna i en polygon.GeometryType — Returnerar typen av geometri som text.
text GeometryType(geometry geomA);
Returnerar geometrins typ som en sträng. T.ex.: "LINESTRING", "POLYGON", "MULTIPOINT", etc.
OGC SPEC s2.1.1.1 - Returnerar namnet på den instantierbara subtypen av Geometry som denna Geometry-instans är medlem av. Namnet på den instansiella subtypen av Geometry returneras som en sträng.
![]() | |
Denna funktion anger också om geometrin är uppmätt genom att returnera en sträng av formen "POINTM". |
Förbättrad: 2.0.0 stöd för polyhedrala ytor, trianglar och TIN infördes.
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
SELECT GeometryType('LINESTRING(77.29 29.07,77.42 29.26,77.27 29.31,77.29 29.07)'::geometry);LINESTRING
SELECT ST_GeometryType('POLYHEDRALSURFACE( ((0 0 0,0 0 1,0 1 1,0 1 0,0 0 0)),
((0 0 0,0 1 0,1 1 0,1 0 0,0 0 0)),((0 0 0,1 0 0,1 0 1,0 0 1,0 0 0)),
((1 1 0,1 1 1,1 0 1,1 0 0,1 1 0)),
((0 1 0,0 1 1,1 1 1,1 1 0,0 1 0)),((0 0 1,1 0 1,1 1 1,0 1 1,0 0 1)) )');
POLYHEDRALSURFACE
SELECT GeometryType(geom) as result
FROM
(SELECT
'TIN (((
0 0 0,
0 0 1,
0 1 0,
0 0 0
)),((
0 0 0,
0 1 0,
1 1 0,
0 0 0
))
)'::geometry AS geom
) AS g;TIN
ST_Boundary — Returnerar gränsen för en geometri.
geometry ST_Boundary(geometry geomA);
Returnerar stängningen av den kombinatoriska gränsen för denna geometri. Den kombinatoriska gränsen definieras enligt beskrivningen i avsnitt 3.12.3.2 i OGC SPEC. Eftersom resultatet av denna funktion är en slutning, och därmed topologiskt sluten, kan den resulterande gränsen representeras med hjälp av representativa geometriprimitiver som diskuteras i OGC SPEC, avsnitt 3.12.2.
Utförs av GEOS-modulen
![]() | |
Före 2.0.0 kastar denna funktion ett undantag om den används med |
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. OGC SPEC s2.1.1.1
Denna metod implementerar SQL/MM-specifikationen. SQL-MM IEC 13249-3: 5.1.17
Denna funktion stöder 3d och kommer inte att tappa z-index.
Förbättrad: 2.1.0-stöd för Triangle infördes
Ändrat: 3.2.0 stöd för TIN, använder inte geos, lineariserar inte kurvor
LineString with boundary points overlaid.
SELECT ST_Boundary(geom)
FROM (SELECT 'LINESTRING(100 150,50 60,70 80,160 170)'::geometry As geom) As f;
MULTIPOINT((100 150),(160 170))
Polygon holes with the boundary MultiLineString overlaid.
SELECT ST_Boundary(geom)
FROM (SELECT
'POLYGON (( 10 130,50 190,110 190,140 150,150 80,100 10,20 40,10 130 ),
( 70 40,100 50,120 80,80 110,50 90,70 40 ))'::geometry As geom) As f;
MULTILINESTRING((10 130,50 190,110 190,140 150,150 80,100 10,20 40,10 130),
(70 40,100 50,120 80,80 110,50 90,70 40))
SELECT ST_Boundary('LINESTRING(1 1,0 0,-1 1)');MULTIPOINT((1 1),(-1 1))
SELECT ST_Boundary('POLYGON((1 1,0 0,-1 1,1 1))');LINESTRING(1 1,0 0,-1 1,1 1)
This example uses a 3D polygon.
SELECT ST_Boundary('POLYGON((1 1 1,0 0 1,-1 1 1,1 1 1))');LINESTRING(1 1 1,0 0 1,-1 1 1,1 1 1)
This example uses a 3D MultiLineString.
SELECT ST_Boundary('MULTILINESTRING((1 1 1,0 0 0.5,-1 1 1),(1 1 0.5,0 0 0.5,-1 1 0.5,1 1 0.5) )');MULTIPOINT(1 1 1,-1 1 1)
ST_BoundingDiagonal — Returnerar diagonalen i en geometris avgränsande box.
geometry ST_BoundingDiagonal(geometry geom, boolean fits=false);
Returnerar diagonalen i den angivna geometrins avgränsande box som en LineString. Diagonalen är en 2-punkts LineString med minimivärdena för varje dimension i startpunkten och maximivärdena i slutpunkten. Om indatageometrin är tom är diagonalen en LINESTRING EMPTY.
Den valfria parametern fits anger om den bästa anpassningen behövs. Om false anges kan diagonalen i en något större avgränsande box accepteras (vilket är snabbare att beräkna för geometrier med många hörn). I båda fallen täcker den returnerade diagonallinjens avgränsningsbox alltid inmatningsgeometrin.
Den returnerade geometrin behåller SRID och dimensionalitet (Z- och M-närvaro) för den inmatade geometrin.
![]() | |
I degenererade fall (t.ex. en enda vertex i indata) kommer den returnerade linjesträngen att vara formellt ogiltig (inget inre). Resultatet är fortfarande topologiskt giltigt. |
Tillgänglighet: 2.2.0
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder M-koordinater.
This example shows a polygon together with the diagonal of its bounding box.
WITH input AS (
SELECT 'POLYGON((10 20,30 60,70 40,90 10,50 -10,10 20))'::geometry AS geom
)
SELECT geom AS input_polygon,
ST_BoundingDiagonal(geom) AS diagonal
FROM input;POLYGON((10 20,30 60,70 40,90 10,50 -10,10 20)) | LINESTRING(10 -10,90 60)
This example returns the minimum X coordinate of a buffer around a point.
SELECT ST_X(ST_StartPoint(ST_BoundingDiagonal( ST_Buffer(ST_Point(0, 0), 10) )));
-10
ST_StartPoint, ST_EndPoint, ST_X, ST_Y, ST_Z, ST_M, ST_Envelope
ST_CoordDim — Returnerar koordinatdimensionen för en geometri.
integer ST_CoordDim(geometry geomA);
Returnerar koordinatdimensionen för ST_Geometry-värdet.
Detta är det MM-kompatibla aliasnamnet för ST_NDims
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.3
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
SELECT ST_CoordDim('CIRCULARSTRING(1 2 3,1 3 4,5 6 7,8 9 10,11 12 13)');3
SELECT ST_CoordDim(ST_Point(1, 2));
2
ST_Dimension — Returnerar den topologiska dimensionen för en geometri.
integer ST_Dimension(geometry g);
Returnerar den topologiska dimensionen för detta Geometry-objekt, som måste vara mindre än eller lika med koordinatdimensionen. OGC SPEC s2.1.1.1 - returnerar 0 för POINT, 1 för LINESTRING, 2 för POLYGON och den största dimensionen för komponenterna i en GEOMETRYCOLLECTION. Om dimensionen är okänd (t.ex. för en tom GEOMETRYCOLLECTION) returneras 0.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.2
![]() | |
A |
Förbättrad: 2.0.0 stöd för polyhedrala ytor och TINs infördes. Kastar inte längre ett undantag om en tom geometri ges.
![]() | |
Före 2.0.0 kastar denna funktion ett undantag om den används med tom geometri. |
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
SELECT ST_Dimension('GEOMETRYCOLLECTION(LINESTRING(1 1,0 0), POINT(0 0))');1
SELECT ST_Dimension('TIN Z (((0 0 0,0 0 1,0 1 0,0 0 0)),((0 0 0,0 1 0,1 0 0,0 0 0)),((0 0 0,1 0 0,0 0 1,0 0 0)),((1 0 0,0 1 0,0 0 1,1 0 0)))');2
ST_Dump — Returnerar en uppsättning geometry_dump-rader för komponenterna i en geometri.
geometry_dump[] ST_Dump(geometry g1);
En set-returning function (SRF) som extraherar komponenterna i en geometri. Den returnerar en uppsättning geometry_dump -rader som var och en innehåller en geometri (fältetgeom) och en array med heltal (fältet path).
För en atomär geometrityp (POINT,LINESTRING,POLYGON) returneras en enda post med en tom sökvägsmatris och indatageometrin som geom. För en samling eller multipelgeometri returneras en post för var och en av samlingens komponenter, och sökvägen anger komponentens position i samlingen.
ST_Dump är användbart för att expandera geometrier. Det är motsatsen till ST_Collect / GROUP BY, eftersom det skapar nya rader. Det kan t.ex. användas för att expandera MULTIPOLYGONER till POLYGONER.
Förbättrad: 2.0.0 stöd för polyhedrala ytor, trianglar och TIN infördes.
Tillgänglighet: PostGIS 1.0.0RC1. Kräver PostgreSQL 7.3 eller högre.
![]() | |
Före 1.3.4 kraschade den här funktionen om den användes med geometrier som innehåller CURVES. Detta är åtgärdat i 1.3.4+ |
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
Denna funktion stöder 3d och kommer inte att tappa z-index.
Dump the components of geometries stored in a table.
SELECT sometable.field1,
(ST_Dump(sometable.geom)).geom AS geom
FROM sometable;Break a CompoundCurve into its constituent LineStrings and CircularStrings.
SELECT a.geom, ST_HasArc(a.geom)
FROM ( SELECT (ST_Dump(p_geom)).geom AS geom
FROM (SELECT 'COMPOUNDCURVE(CIRCULARSTRING(0 0,1 1,1 0),(1 0,0 1))'::geometry AS p_geom) AS b
) AS a;st_asewkt | st_hasarc -----------------------------+---------- CIRCULARSTRING(0 0,1 1,1 0) | t LINESTRING(1 0,0 1) | f (2 rows)
This example breaks a PolyhedralSurface into its faces.
SELECT (a.p_geom).path[1] As path,(a.p_geom).geom As geom_ewkt
FROM (SELECT ST_Dump('POLYHEDRALSURFACE(
((0 0 0,0 0 1,0 1 1,0 1 0,0 0 0)),
((0 0 0,0 1 0,1 1 0,1 0 0,0 0 0)),((0 0 0,1 0 0,1 0 1,0 0 1,0 0 0)),((1 1 0,1 1 1,1 0 1,1 0 0,1 1 0)),
((0 1 0,0 1 1,1 1 1,1 1 0,0 1 0)),((0 0 1,1 0 1,1 1 1,0 1 1,0 0 1))
)' ) AS p_geom ) AS a;path | geom_ewkt
------+------------------------------------------
1 | POLYGON((0 0 0,0 0 1,0 1 1,0 1 0,0 0 0))
2 | POLYGON((0 0 0,0 1 0,1 1 0,1 0 0,0 0 0))
3 | POLYGON((0 0 0,1 0 0,1 0 1,0 0 1,0 0 0))
4 | POLYGON((1 1 0,1 1 1,1 0 1,1 0 0,1 1 0))
5 | POLYGON((0 1 0,0 1 1,1 1 1,1 1 0,0 1 0))
6 | POLYGON((0 0 1,1 0 1,1 1 1,0 1 1,0 0 1))This example uses a TIN geometry.
SELECT (g.gdump).path,(g.gdump).geom as wkt
FROM
(SELECT
ST_Dump('TIN (((
0 0 0,
0 0 1,
0 1 0,
0 0 0
)),((
0 0 0,
0 1 0,
1 1 0,
0 0 0
))
)' ) AS gdump
) AS g;path | wkt
------+-------------------------------------
{1} | TRIANGLE((0 0 0,0 0 1,0 1 0,0 0 0))
{2} | TRIANGLE((0 0 0,0 1 0,1 1 0,0 0 0))
ST_DumpPoints — Returnerar en uppsättning geometry_dump-rader för koordinaterna i en geometri.
geometry_dump[] ST_DumpPoints(geometry geom);
En set-returning function (SRF) som extraherar koordinaterna (hörnen) för en geometri. Den returnerar en uppsättning geometry_dump -rader, som var och en innehåller en geometri (fältetgeom) och en array av heltal (fältet path).
geom-fältet POINTsrepresenterar koordinaterna för den medföljande geometrin.
path-fältet (ett integer[]) är ett index som räknar upp koordinatpositionerna i elementen i den angivna geometrin. Indexen är 1-baserade. Till exempel för en LINESTRING är banorna {i} där i är den n:te koordinaten i LINESTRING. För en POLYGON är banorna {i,j} där i är ringnumret (1 är den yttre ringen; de inre ringarna följer) och j är koordinatpositionen i ringen.
För att få en enda geometri som innehåller koordinaterna, använd ST_Points.
Förbättrad: 2.1.0 Snabbare hastighet. Återimplementerad som native-C.
Förbättrad: 2.0.0 stöd för polyhedrala ytor, trianglar och TIN infördes.
Tillgänglighet: 1.5.0
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
Denna funktion stöder 3d och kommer inte att tappa z-index.
Explode a table of LineStrings into their vertices.
SELECT edge_id, (dp).path[1] As index,(dp).geom As wktnode
FROM (SELECT 1 As edge_id,
ST_DumpPoints(ST_GeomFromText('LINESTRING(1 2,3 4,10 10)')) AS dp
UNION ALL
SELECT 2 As edge_id,
ST_DumpPoints(ST_GeomFromText('LINESTRING(3 5,5 6,9 10)')) AS dp
) As foo;edge_id | index | wktnode
---------+-------+--------------
1 | 1 | POINT(1 2)
1 | 2 | POINT(3 4)
1 | 3 | POINT(10 10)
2 | 1 | POINT(3 5)
2 | 2 | POINT(5 6)
2 | 3 | POINT(9 10)Dump every vertex from a mixed GeometryCollection.
SELECT path,geom
FROM (
SELECT (ST_DumpPoints(g.geom)).*
FROM
(SELECT
'GEOMETRYCOLLECTION(
POINT ( 0 1 ),
LINESTRING ( 0 3,3 4 ),
POLYGON (( 2 0,2 3,0 2,2 0 )),
POLYGON (( 3 0,3 3,6 3,6 0,3 0 ),
( 5 1,4 2,5 2,5 1 )),
MULTIPOLYGON (
(( 0 5,0 8,4 8,4 5,0 5 ),
( 1 6,3 6,2 7,1 6 )),
(( 5 4,5 8,6 7,5 4 ))
)
)'::geometry AS geom
) AS g
) j;path | st_astext
-----------+------------
{1,1} | POINT(0 1)
{2,1} | POINT(0 3)
{2,2} | POINT(3 4)
{3,1,1} | POINT(2 0)
{3,1,2} | POINT(2 3)
{3,1,3} | POINT(0 2)
{3,1,4} | POINT(2 0)
{4,1,1} | POINT(3 0)
{4,1,2} | POINT(3 3)
{4,1,3} | POINT(6 3)
{4,1,4} | POINT(6 0)
{4,1,5} | POINT(3 0)
{4,2,1} | POINT(5 1)
{4,2,2} | POINT(4 2)
{4,2,3} | POINT(5 2)
{4,2,4} | POINT(5 1)
{5,1,1,1} | POINT(0 5)
{5,1,1,2} | POINT(0 8)
{5,1,1,3} | POINT(4 8)
{5,1,1,4} | POINT(4 5)
{5,1,1,5} | POINT(0 5)
{5,1,2,1} | POINT(1 6)
{5,1,2,2} | POINT(3 6)
{5,1,2,3} | POINT(2 7)
{5,1,2,4} | POINT(1 6)
{5,2,1,1} | POINT(5 4)
{5,2,1,2} | POINT(5 8)
{5,2,1,3} | POINT(6 7)
{5,2,1,4} | POINT(5 4)
(29 rows)Collect the dumped vertices to visualize them over the source geometry.
WITH source(geom) AS (VALUES (
'GEOMETRYCOLLECTION(
POINT (0 1),
LINESTRING (0 3,3 4),
POLYGON ((2 0,2 3,0 2,2 0)),
POLYGON ((3 0,3 3,6 3,6 0,3 0),(5 1,4 2,5 2,5 1)),
MULTIPOLYGON (((0 5,0 8,4 8,4 5,0 5),(1 6,3 6,2 7,1 6)),
((5 4,5 8,6 7,5 4))))'::geometry
))
SELECT ST_Collect((dp).geom ORDER BY (dp).path) AS vertices
FROM source
CROSS JOIN LATERAL ST_DumpPoints(source.geom) AS dp;MULTIPOINT((0 1),(0 3),(3 4),(2 0),(2 3),(0 2),(2 0),(3 0),(3 3),(6 3),(6 0),(3 0),(5 1),(4 2),(5 2),(5 1),(0 5),(0 8),(4 8),(4 5),(0 5),(1 6),(3 6),(2 7),(1 6),(5 4),(5 8),(6 7),(5 4))
This example uses a cube represented as a PolyhedralSurface.
SELECT (g.gdump).path,(g.gdump).geom as wkt
FROM
(SELECT
ST_DumpPoints('POLYHEDRALSURFACE( ((0 0 0,0 0 1,0 1 1,0 1 0,0 0 0)),
((0 0 0,0 1 0,1 1 0,1 0 0,0 0 0)),((0 0 0,1 0 0,1 0 1,0 0 1,0 0 0)),
((1 1 0,1 1 1,1 0 1,1 0 0,1 1 0)),
((0 1 0,0 1 1,1 1 1,1 1 0,0 1 0)),((0 0 1,1 0 1,1 1 1,0 1 1,0 0 1)) )' ) AS gdump
) AS g;path | wkt
---------+--------------
{1,1,1} | POINT(0 0 0)
{1,1,2} | POINT(0 0 1)
{1,1,3} | POINT(0 1 1)
{1,1,4} | POINT(0 1 0)
{1,1,5} | POINT(0 0 0)
{2,1,1} | POINT(0 0 0)
{2,1,2} | POINT(0 1 0)
{2,1,3} | POINT(1 1 0)
{2,1,4} | POINT(1 0 0)
{2,1,5} | POINT(0 0 0)
{3,1,1} | POINT(0 0 0)
{3,1,2} | POINT(1 0 0)
{3,1,3} | POINT(1 0 1)
{3,1,4} | POINT(0 0 1)
{3,1,5} | POINT(0 0 0)
{4,1,1} | POINT(1 1 0)
{4,1,2} | POINT(1 1 1)
{4,1,3} | POINT(1 0 1)
{4,1,4} | POINT(1 0 0)
{4,1,5} | POINT(1 1 0)
{5,1,1} | POINT(0 1 0)
{5,1,2} | POINT(0 1 1)
{5,1,3} | POINT(1 1 1)
{5,1,4} | POINT(1 1 0)
{5,1,5} | POINT(0 1 0)
{6,1,1} | POINT(0 0 1)
{6,1,2} | POINT(1 0 1)
{6,1,3} | POINT(1 1 1)
{6,1,4} | POINT(0 1 1)
{6,1,5} | POINT(0 0 1)
(30 rows)This example uses a Triangle geometry.
SELECT (g.gdump).path,(g.gdump).geom as wkt
FROM
(SELECT
ST_DumpPoints('TRIANGLE ((
0 0,
0 9,
9 0,
0 0
))' ) AS gdump
) AS g;path | wkt
------+------------
{1,1} | POINT(0 0)
{1,2} | POINT(0 9)
{1,3} | POINT(9 0)
{1,4} | POINT(0 0)This example uses a TIN geometry.
SELECT (g.gdump).path,(g.gdump).geom as wkt
FROM
(SELECT
ST_DumpPoints('TIN (((
0 0 0,
0 0 1,
0 1 0,
0 0 0
)),((
0 0 0,
0 1 0,
1 1 0,
0 0 0
))
)' ) AS gdump
) AS g;path | wkt
---------+--------------
{1,1,1} | POINT(0 0 0)
{1,1,2} | POINT(0 0 1)
{1,1,3} | POINT(0 1 0)
{1,1,4} | POINT(0 0 0)
{2,1,1} | POINT(0 0 0)
{2,1,2} | POINT(0 1 0)
{2,1,3} | POINT(1 1 0)
{2,1,4} | POINT(0 0 0)
(8 rows)ST_DumpSegments — Returnerar en uppsättning geometry_dump-rader för segmenten i en geometri.
geometry_dump[] ST_DumpSegments(geometry geom);
En set-returning function (SRF) som extraherar segmenten i en geometri. Den returnerar en uppsättning geometry_dump rader, var och en innehållande en geometri (fältetgeom) och en array av heltal (fältet path).
geom-fältet LINESTRINGsrepresenterar de linjära segmenten i den medföljande geometrin, medan CIRCULARSTRINGsrepresenterar bågsegmenten.
path-fältet (ett integer[]) är ett index som räknar upp segmentets startpunktspositioner i elementen i den angivna geometrin. Indexen är 1-baserade. Till exempel för en LINESTRING är banorna {i} där i är den n:te startpunkten för segmentet i LINESTRING. För en POLYGON är banorna {i,j} där i är ringnumret (1 är yttre; inre ringar följer) och j är segmentets startpunktsposition i ringen.
Tillgänglighet: 3.2.0
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
Denna funktion stöder 3d och kommer inte att tappa z-index.
SELECT path,geom
FROM (
SELECT (ST_DumpSegments(g.geom)).*
FROM (SELECT 'GEOMETRYCOLLECTION(
LINESTRING(1 1,3 3,4 4),
POLYGON((5 5,6 6,7 7,5 5))
)'::geometry AS geom
) AS g
) j;path │ st_astext
---------------------------------
{1,1} │ LINESTRING(1 1,3 3)
{1,2} │ LINESTRING(3 3,4 4)
{2,1,1} │ LINESTRING(5 5,6 6)
{2,1,2} │ LINESTRING(6 6,7 7)
{2,1,3} │ LINESTRING(7 7,5 5)
(5 rows)This example uses a Triangle geometry.
SELECT path,geom
FROM (
SELECT (ST_DumpSegments(g.geom)).*
FROM (SELECT 'TRIANGLE((
0 0,
0 9,
9 0,
0 0
))'::geometry AS geom
) AS g
) j;path │ st_astext
---------------------------------
{1,1} │ LINESTRING(0 0,0 9)
{1,2} │ LINESTRING(0 9,9 0)
{1,3} │ LINESTRING(9 0,0 0)
(3 rows)This example uses a TIN geometry.
SELECT path,geom
FROM (
SELECT (ST_DumpSegments(g.geom)).*
FROM (SELECT 'TIN(((
0 0 0,
0 0 1,
0 1 0,
0 0 0
)),((
0 0 0,
0 1 0,
1 1 0,
0 0 0
))
)'::geometry AS geom
) AS g
) j;path │ st_asewkt
---------------------------------
{1,1,1} │ LINESTRING(0 0 0,0 0 1)
{1,1,2} │ LINESTRING(0 0 1,0 1 0)
{1,1,3} │ LINESTRING(0 1 0,0 0 0)
{2,1,1} │ LINESTRING(0 0 0,0 1 0)
{2,1,2} │ LINESTRING(0 1 0,1 1 0)
{2,1,3} │ LINESTRING(1 1 0,0 0 0)
(6 rows)ST_DumpRings — Returnerar en uppsättning geometry_dump-rader för de yttre och inre ringarna i en polygon.
geometry_dump[] ST_DumpRings(geometry a_polygon);
En set-returning function (SRF) som extraherar ringarna i en polygon. Den returnerar en uppsättning geometry_dump rader, var och en innehållande en geometri(geom-fält) och en array av heltal(path-fält).
Fältet geom innehåller varje ring som en POLYGON. Fältet path är en heltalsarray med längden 1 som innehåller polygonringens index. Den yttre ringen (skalet) har index 0. De inre ringarna (hålen) har index 1 och högre.
![]() | |
This only works for POLYGON geometries, not MULTIPOLYGONs. Use ST_Dump to extract polygon elements from polygonal geometries: |
Tillgänglighet: PostGIS 1.1.3. Kräver PostgreSQL 7.3 eller högre.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Extracting all rings as polygons.
SELECT polyTable.field1, polyTable.field1,
(ST_DumpRings(polyTable.geom)).geom As geom
FROM polyTable
Extracting shell and holes from a polygon.
SELECT path,geom As geom
FROM ST_DumpRings('POLYGON ((1 9,9 9,9 1,1 1,1 9),(2 2,2 3,3 3,3 2,2 2),(4 2,4 4,6 4,6 2,4 2))');path | geom
------+--------------------------------
{0} | POLYGON((1 9,9 9,9 1,1 1,1 9))
{1} | POLYGON((2 2,2 3,3 3,3 2,2 2))
{2} | POLYGON((4 2,4 4,6 4,6 2,4 2))Finding interior rings which lie close to the exterior ring.
WITH poly AS (
SELECT 'POLYGON ((
0 0, 10 0, 10 10, 0 10, 0 0
), (
1 1, 1 2, 2 2, 2 1, 1 1
), (
8.5 1, 8.5 2, 9.5 2, 9.5 1, 8.5 1
))'::geometry AS geom
),
rings AS (
SELECT d.path[1] AS ring_no,
ST_Boundary(d.geom) AS ring_geom
FROM poly
CROSS JOIN LATERAL ST_DumpRings(poly.geom) AS d
),
shell AS (
SELECT ring_geom
FROM rings
WHERE ring_no = 0
),
holes AS (
SELECT ring_no, ring_geom
FROM rings
WHERE ring_no > 0
)
SELECT h.ring_no,
ST_Normalize(ST_Multi(ST_LineMerge(
ST_Intersection(ST_Buffer(s.ring_geom, 1.0), h.ring_geom)
))) AS close_part
FROM shell AS s
JOIN holes AS h
ON ST_DWithin(s.ring_geom, h.ring_geom, 1.0);
ring_no | close_part
---------+-------------------------------------------------
1 | MULTILINESTRING((1 2,1 1,2 1))
2 | MULTILINESTRING((8.5 1,9 1,9.5 1,9.5 2,9 2))
ST_EndPoint — Returns the last point of a LineString, CircularLineString, or NURBSCurve.
geometry ST_EndPoint(geometry g);
Returns the last point of a LINESTRING, CIRCULARLINESTRING, or NURBSCURVE geometry as a POINT. Returns NULL if the input is not a LINESTRING, CIRCULARLINESTRING, or NURBSCURVE.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 7.1.4
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
Ändrad: 2.0.0 fungerar inte längre med MultiLineStrings med en geometri. I äldre versioner av PostGIS skulle en MultiLineString med en enda rad fungera med den här funktionen och returnera slutpunkten. I 2.0.0 returnerar den NULL som vilken annan MultiLineString som helst. Det gamla beteendet var en odokumenterad funktion, men personer som antog att de hade sina data lagrade som LINESTRING kan uppleva att dessa returnerar NULL i 2.0.0.
Slutpunkt för en LineString
SELECT ST_EndPoint('LINESTRING(1 1,2 2,3 3)'::geometry);POINT(3 3)
Slutpunkten för en icke-LineString är NULL
SELECT ST_EndPoint('POINT(1 1)'::geometry) IS NULL AS is_null;t
Slutpunkt för en 3D-linjeString
3D endpoint.
SELECT ST_EndPoint('LINESTRING(1 1 2,1 2 3,0 0 5)');POINT(0 0 5)
Slutpunkt för en CircularString
SELECT ST_EndPoint('CIRCULARSTRING(5 2,-3 2,-2 1,-4 2,6 3)'::geometry);POINT(6 3)
End point of a NURBSCurve
SELECT ST_EndPoint('NURBSCURVE(2, (0 0, 1 1, 2 0))'::geometry);POINT(2 0)
ST_Envelope — Returnerar en geometri som representerar en geometris avgränsande box.
geometry ST_Envelope(geometry g1);
Returnerar den minsta avgränsningsboxen med dubbel precision (float8) för den angivna geometrin, som en geometri. Polygonen definieras av hörnpunkterna i begränsningsboxen (((MINX, MINY), (MINX, MAXY),(MAXX, MAXY),(MAXX, MINY), (MINX, MINY)). (PostGIS kommer även att lägga till en ZMIN/ZMAX-koordinat ).
Degenererade fall (vertikala linjer, punkter) kommer att returnera en geometri med lägre dimension än POLYGON, dvs. POINT eller LINESTRING.
Tillgänglighet: 1.5.0 ändrat beteende för att mata ut dubbel precision istället för float4
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s2.1.1.1
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.19
SELECT ST_Envelope('POINT(1 3)'::geometry);POINT(1 3)
SELECT ST_Envelope('LINESTRING(0 0,1 3)'::geometry);POLYGON((0 0,0 3,1 3,1 0,0 0))
SELECT ST_Envelope('POLYGON((0 0,0 1,1.0000001 1,1.0000001 0,0 0))'::geometry);POLYGON((0 0,0 1,1.0000001 1,1.0000001 0,0 0))
SELECT ST_Envelope('POLYGON((0 0,0 1,1.0000000001 1,1.0000000001 0,0 0))'::geometry);POLYGON((0 0,0 1,1.0000000001 1,1.0000000001 0,0 0))
SELECT Box3D(geom), Box2D(geom), ST_Envelope(geom) As envelopewkt
FROM (SELECT 'POLYGON((0 0,0 1000012333334.34545678,1.0000001 1,1.0000001 0,0 0))'::geometry As geom) As foo;
Envelope of a point and LineString.
SELECT ST_Envelope(ST_Collect(
'LINESTRING(55 75,125 150)',
ST_Point(20, 80)
)) As wktenv;POLYGON((20 75,20 150,125 150,125 75,20 75))
ST_ExteriorRing — Returnerar en LineString som representerar den yttre ringen av en Polygon.
geometry ST_ExteriorRing(geometry a_polygon);
Returnerar en LINESTRING som representerar den yttre ringen (skalet) av en POLYGON. Returnerar NULL om geometrin inte är en polygon.
![]() | |
Denna funktion stöder inte MULTIPOLYGON. För MULTIPOLYGON, använd tillsammans med ST_GeometryN eller ST_Dump |
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. 2.1.5.1
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 8.2.3, 8.3.3
Denna funktion stöder 3d och kommer inte att tappa z-index.
Extract the exterior ring from a Polygon with a hole.
WITH input(geom) AS (VALUES (
'POLYGON((0 0,2 9,9 11,14 6,12 0,0 0),(4 3,9 3,10 7,5 8,4 3))'::geometry
))
SELECT geom AS input_polygon,
ST_ExteriorRing(geom) AS exterior_ring
FROM input;POLYGON((0 0,2 9,9 11,14 6,12 0,0 0),(4 3,9 3,10 7,5 8,4 3)) | LINESTRING(0 0,2 9,9 11,14 6,12 0,0 0)
For a MultiPolygon, dump the component Polygons before extracting their exterior rings. Both component Polygons in this example have holes.
WITH input(geom) AS (VALUES (
'MULTIPOLYGON(
((0 0,2 9,9 11,14 6,12 0,0 0),(4 3,9 3,10 7,5 8,4 3)),
((18 1,18 10,29 10,31 4,25 0,18 1),(21 3,25 2,28 5,25 8,21 7,21 3))
)'::geometry
))
SELECT part.geom AS input_polygon,
ST_ExteriorRing(part.geom) AS exterior_ring
FROM input
CROSS JOIN LATERAL ST_Dump(geom) AS part
ORDER BY part.path;POLYGON((0 0,2 9,9 11,14 6,12 0,0 0),(4 3,9 3,10 7,5 8,4 3)) | LINESTRING(0 0,2 9,9 11,14 6,12 0,0 0) POLYGON((18 1,18 10,29 10,31 4,25 0,18 1),(21 3,25 2,28 5,25 8,21 7,21 3)) | LINESTRING(18 1,18 10,29 10,31 4,25 0,18 1)
Extract exterior rings from a table of Polygons.
SELECT gid, ST_ExteriorRing(geom) AS ering FROM sometable;
For a table of MultiPolygons, dump the component Polygons and collect their exterior rings into a MultiLineString.
SELECT gid, ST_Collect(ST_ExteriorRing(geom)) AS erings FROM ( SELECT gid, (ST_Dump(geom)).geom AS geom FROM sometable ) AS foo GROUP BY gid;
This example returns the 3D exterior ring of a Polygon.
SELECT ST_ExteriorRing(
'POLYGON Z ((0 0 5,4 0 5,4 3 5,0 3 5,0 0 5))'
);LINESTRING(0 0 5,4 0 5,4 3 5,0 3 5,0 0 5)
ST_GeometryN — Returnerar ett element i en geometrisamling.
geometry ST_GeometryN(geometry geomA, integer n);
Returns the 1-based Nth element of a GEOMETRYCOLLECTION, MULTIPOINT, MULTILINESTRING, MULTICURVE, or MULTIPOLYGON. For a unitary geometry, including a TIN or PolyhedralSurface, an index of 1 returns the input geometry and any other index returns NULL. Use ST_PatchN and ST_NumPatches to access and count the faces of a TIN or PolyhedralSurface.
![]() | |
Index är 1-baserat som för OGC-specifikationer sedan version 0.8.0. Tidigare versioner implementerade detta som 0-baserat istället. |
![]() | |
För att extrahera alla element i en geometri är ST_Dump mer effektivt och fungerar för atomgeometrier. |
Förbättrad: 2.0.0 stöd för polyhedrala ytor, trianglar och TIN infördes.
Ändrad: 2.0.0 Tidigare versioner skulle returnera NULL för singulära geometrier. Detta ändrades till att returnera geometrin för ST_GeometryN(..,1) fallet.
Changed: 3.6.0 TIN and PolyhedralSurface are treated as unitary geometries and are not decomposed into patches; use ST_PatchN to access faces.
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 9.1.5
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
Extracting a subset of points from a 3D multipoint.
SELECT n, ST_GeometryN(geom, n) As geomewkt
FROM (
VALUES
(1, 'MULTIPOINT((1 2 7), (3 4 7), (5 6 7), (8 9 10))'::geometry ),
(2, 'MULTICURVE(CIRCULARSTRING(2.5 2.5,4.5 2.5, 3.5 3.5), (10 11, 12 11))'::geometry )
) As foo(id, geom)
CROSS JOIN generate_series(1,100) n
WHERE n <= ST_NumGeometries(geom)
ORDER BY id, n;
n | geomewkt ---+----------------------------------------- 1 | POINT(1 2 7) 2 | POINT(3 4 7) 3 | POINT(5 6 7) 4 | POINT(8 9 10) 1 | CIRCULARSTRING(2.5 2.5,4.5 2.5,3.5 3.5) 2 | LINESTRING(10 11,12 11)
Extracting all geometries (useful when you want to assign an id).
SELECT gid, n, ST_GeometryN(geom, n) FROM sometable CROSS JOIN generate_series(1,100) n WHERE n <= ST_NumGeometries(geom);
A PolyhedralSurface or TIN is treated as a single geometry, not as a collection of faces. ST_GeometryN does not decompose the surface into patches, so an index greater than 1 returns NULL. Use ST_PatchN and ST_NumPatches to access individual faces.
This example requests the third element of a PolyhedralSurface.
SELECT ST_GeometryN(p_geom, 3) As geom_ewkt FROM (SELECT 'POLYHEDRALSURFACE( ((0 0 0,0 0 1,0 1 1,0 1 0,0 0 0)), ((0 0 0,0 1 0,1 1 0,1 0 0,0 0 0)), ((0 0 0,1 0 0,1 0 1,0 0 1,0 0 0)), ((1 1 0,1 1 1,1 0 1,1 0 0,1 1 0)), ((0 1 0,0 1 1,1 1 1,1 1 0,0 1 0)), ((0 0 1,1 0 1,1 1 1,0 1 1,0 0 1)) )'::geometry AS p_geom ) AS a;
NULL
This example requests the second element of a TIN.
SELECT ST_GeometryN(geom, 2) as wkt
FROM
(SELECT
'TIN (((
0 0 0,
0 0 1,
0 1 0,
0 0 0
)),((
0 0 0,
0 1 0,
1 1 0,
0 0 0
))
)'::geometry AS geom
) AS g;NULL
ST_GeometryType — Returnerar SQL-MM-typen för en geometri som text.
text ST_GeometryType(geometry g1);
Returnerar geometrins typ som en sträng. EG: "ST_LineString", "ST_Polygon", "ST_MultiPolygon" etc. Denna funktion skiljer sig från GeometryType(geometry) när det gäller strängen och ST framför som returneras, samt det faktum att den inte kommer att ange om geometrin är uppmätt.
Förbättrad: 2.0.0 stöd för polyhedrala ytor infördes.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.4
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
SELECT ST_GeometryType('LINESTRING(77.29 29.07,77.42 29.26,77.27 29.31,77.29 29.07)'::geometry);ST_LineString
SELECT ST_GeometryType('POLYHEDRALSURFACE( ((0 0 0,0 0 1,0 1 1,0 1 0,0 0 0)),
((0 0 0,0 1 0,1 1 0,1 0 0,0 0 0)),((0 0 0,1 0 0,1 0 1,0 0 1,0 0 0)),
((1 1 0,1 1 1,1 0 1,1 0 0,1 1 0)),
((0 1 0,0 1 1,1 1 1,1 1 0,0 1 0)),((0 0 1,1 0 1,1 1 1,0 1 1,0 0 1)) )'::geometry);ST_PolyhedralSurface
SELECT ST_GeometryType(geom) AS result
FROM
(SELECT
'TIN (((
0 0 0,
0 0 1,
0 1 0,
0 0 0
)),((
0 0 0,
0 1 0,
1 1 0,
0 0 0
))
)'::geometry AS geom
) AS g;ST_Tin
ST_HasArc — Testar om en geometri innehåller en cirkelbåge
boolean ST_HasArc(geometry geomA);
Returnerar true om en geometri eller geometrisamling innehåller en cirkulär sträng
Tillgänglighet: 1.2.3?
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
SELECT ST_HasArc(ST_Collect('LINESTRING(1 2,3 4,5 6)', 'CIRCULARSTRING(1 1,2 3,4 5,6 7,5 6)'));t
ST_InteriorRingN — Returnerar den N:te inre ringen (hålet) i en polygon.
geometry ST_InteriorRingN(geometry a_polygon, integer n);
Returnerar den N:te inre ringen (hålet) i en POLYGON-geometri som en LINESTRING. Indexet börjar på 1. Returnerar NULL om geometrin inte är en polygon eller om indexet är utanför intervallet.
![]() | |
Denna funktion stöder inte MULTIPOLYGON. För MULTIPOLYGON, använd tillsammans med ST_GeometryN eller ST_Dump |
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 8.2.6, 8.3.5
Denna funktion stöder 3d och kommer inte att tappa z-index.
WITH data AS (
SELECT ST_BuildArea(ST_Collect(
ST_Buffer(ST_Point(1, 2), 20, 3),
ST_Buffer(ST_Point(1, 2), 10, 3)
)) AS geom
)
SELECT geom AS input_polygon,
ST_InteriorRingN(geom, 1) AS ring
FROM data;POLYGON((21 2,18.320508075688775 -7.999999999999998,11.000000000000002 -15.320508075688771,1 -18,-8.999999999999996 -15.320508075688775,-16.32050807568877 -8.000000000000007,-19 2,-16.320508075688778 11.999999999999995,-9.000000000000009 19.320508075688767,1 22,10.999999999999986 19.32050807568878,18.320508075688767 12.000000000000009,21 2),(11 2,9.660254037844384 7.000000000000004,5.999999999999993 10.66025403784439,1 12,-4.000000000000004 10.660254037844384,-7.660254037844389 6.999999999999997,-9 2,-7.660254037844386 -3.000000000000004,-3.999999999999998 -6.660254037844387,1 -8,6.000000000000001 -6.660254037844386,9.660254037844387 -2.999999999999999,11 2)) | LINESTRING(11 2,9.660254037844384 7.000000000000004,5.999999999999993 10.66025403784439,1 12,-4.000000000000004 10.660254037844384,-7.660254037844389 6.999999999999997,-9 2,-7.660254037844386 -3.000000000000004,-3.999999999999998 -6.660254037844387,1 -8,6.000000000000001 -6.660254037844386,9.660254037844387 -2.999999999999999,11 2)
ST_NumCurves — Returnerar antalet komponentkurvor i en CompoundCurve.
integer ST_NumCurves(geometry a_compoundcurve);
Returnerar antalet komponentkurvor i en CompoundCurve, noll för en tom CompoundCurve, eller NULL för en icke-CompoundCurve-indata.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 8.2.6, 8.3.5
Denna funktion stöder 3d och kommer inte att tappa z-index.
This CompoundCurve contains three component curves.
SELECT ST_NumCurves('COMPOUNDCURVE(
(2 2,2.5 2.5),
CIRCULARSTRING(2.5 2.5,4.5 2.5,3.5 3.5),
(3.5 3.5,2.5 4.5,3 5,2 2)
)');3
An empty CompoundCurve has no component curves.
SELECT ST_NumCurves('COMPOUNDCURVE EMPTY');0
ST_CurveN — Returnerar den N:te komponentkurvgeometrin för en CompoundCurve.
geometry ST_CurveN(geometry a_compoundcurve, integer index);
Returnerar den N:te komponentkurvgeometrin i en CompoundCurve. Indexet börjar på 1. Returnerar NULL om geometrin inte är en CompoundCurve eller om indexet är utanför intervallet.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 8.2.6, 8.3.5
Denna funktion stöder 3d och kommer inte att tappa z-index.
This example extracts the second component curve, a CircularString, from a CompoundCurve.
SELECT ST_CurveN(
'COMPOUNDCURVE(
(0 0,2 0),
CIRCULARSTRING(2 0,3 1,4 0),
(4 0,6 1)
)',
2) AS curve;CIRCULARSTRING(2 0,3 1,4 0)
ST_IsClosed — Testar om en LineStrings start- och slutpunkter är sammanfallande. För en PolyhedralSurface testas om den är sluten (volymetrisk).
boolean ST_IsClosed(geometry g);
Returnerar TRUE om LINESTRINGs start- och slutpunkter är sammanfallande. För polyedriska ytor rapporteras om ytan är areell (öppen) eller volymetrisk (sluten).
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 7.1.5, 9.3.3
![]() | |
SQL-MM definierar att resultatet av |
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
Förbättrad: 2.0.0 stöd för polyhedrala ytor infördes.
Denna funktion stöder polyedriska ytor.
SELECT ST_IsClosed('LINESTRING(0 0,1 1)'::geometry);f
SELECT ST_IsClosed('LINESTRING(0 0,0 1,1 1,0 0)'::geometry);t
SELECT ST_IsClosed('MULTILINESTRING((0 0,0 1,1 1,0 0),(0 0,1 1))'::geometry);f
SELECT ST_IsClosed('POINT(0 0)'::geometry);t
SELECT ST_IsClosed('MULTIPOINT((0 0),(1 1))'::geometry);t
This example uses a cube.
SELECT ST_IsClosed('POLYHEDRALSURFACE( ((0 0 0,0 0 1,0 1 1,0 1 0,0 0 0)),
((0 0 0,0 1 0,1 1 0,1 0 0,0 0 0)),((0 0 0,1 0 0,1 0 1,0 0 1,0 0 0)),
((1 1 0,1 1 1,1 0 1,1 0 0,1 1 0)),
((0 1 0,0 1 1,1 1 1,1 1 0,0 1 0)),((0 0 1,1 0 1,1 1 1,0 1 1,0 0 1)) )');t
This example uses the same cube with one side missing.
SELECT ST_IsClosed('POLYHEDRALSURFACE( ((0 0 0,0 0 1,0 1 1,0 1 0,0 0 0)),
((0 0 0,0 1 0,1 1 0,1 0 0,0 0 0)),((0 0 0,1 0 0,1 0 1,0 0 1,0 0 0)),
((1 1 0,1 1 1,1 0 1,1 0 0,1 1 0)),
((0 1 0,0 1 1,1 1 1,1 1 0,0 1 0)) )');f
ST_IsCollection — Testar om en geometri är en geometrisamlingstyp.
boolean ST_IsCollection(geometry g);
Returnerar TRUE om argumentets geometrityp är en geometrisamlingstyp. Samlingstyperna är följande:
GEOMETRYCOLLECTION
MULTI{POINT,POLYGON,LINESTRING,CURVE,SURFACE}
COMPOUNDCURVE
![]() | |
Denna funktion analyserar geometrins typ. Detta innebär att den kommer att returnera |
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
SELECT ST_IsCollection('LINESTRING(0 0,1 1)'::geometry);f
SELECT ST_IsCollection('MULTIPOINT EMPTY'::geometry);t
SELECT ST_IsCollection('MULTIPOINT((0 0))'::geometry);t
SELECT ST_IsCollection('MULTIPOINT((0 0),(42 42))'::geometry);t
SELECT ST_IsCollection('GEOMETRYCOLLECTION(POINT(0 0))'::geometry);t
ST_IsEmpty — Testar om en geometri är tom.
boolean ST_IsEmpty(geometry geomA);
Returnerar true om denna geometri är en tom geometri. Om true, så representerar denna geometri en tom geometrisamling, polygon, punkt etc.
![]() | |
SQL-MM definierar att resultatet av ST_IsEmpty(NULL) ska vara 0, medan PostGIS returnerar NULL. |
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s2.1.1.1
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.7
Denna metod stöder cirkulära strängar och kurvor.
Ändrad: 2.0.0 I tidigare versioner av PostGIS var ST_GeomFromText('GEOMETRYCOLLECTION(EMPTY)') tillåtet. Detta är nu olagligt i PostGIS 2.0.0 för att bättre överensstämma med SQL/MM-standarder
SELECT ST_IsEmpty('GEOMETRYCOLLECTION EMPTY'::geometry);t
SELECT ST_IsEmpty('POLYGON EMPTY'::geometry);t
SELECT ST_IsEmpty('POLYGON((1 2,3 4,5 6,1 2))'::geometry);f
SELECT ST_IsEmpty('POLYGON((1 2,3 4,5 6,1 2))'::geometry) = false;t (1 row)
SELECT ST_IsEmpty('CIRCULARSTRING EMPTY'::geometry);t
ST_IsPolygonCCW — Testar om polygoner har yttre ringar som är orienterade moturs och inre ringar som är orienterade medurs.
boolean ST_IsPolygonCCW(geometry geom);
Returnerar true om alla polygonala komponenter i indatageometrin använder en motsols orientering för sin yttre ring och en medsols riktning för alla inre ringar.
Returnerar true om geometrin inte har några polygonala komponenter.
![]() | |
Slutna linestrings betraktas inte som polygonala komponenter, så du skulle fortfarande få ett sant resultat genom att skicka en enda sluten linestrings oavsett dess orientering. |
![]() | |
Om en polygonal geometri inte använder omvänd orientering för inre ringar (d.v.s. om en eller flera inre ringar är orienterade i samma riktning som en yttre ring) kommer både ST_IsPolygonCW och ST_IsPolygonCCW att returnera false. |
Tillgänglighet: 2.4.0
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder M-koordinater.
ST_IsPolygonCW — Testar om polygoner har yttre ringar som är orienterade medurs och inre ringar som är orienterade moturs.
boolean ST_IsPolygonCW(geometry geom);
Returnerar true om alla polygonala komponenter i indatageometrin använder en medurs riktning för sin yttre ring och en moturs riktning för alla inre ringar.
Returnerar true om geometrin inte har några polygonala komponenter.
![]() | |
Slutna linestrings betraktas inte som polygonala komponenter, så du skulle fortfarande få ett sant resultat genom att skicka en enda sluten linestrings oavsett dess orientering. |
![]() | |
Om en polygonal geometri inte använder omvänd orientering för inre ringar (d.v.s. om en eller flera inre ringar är orienterade i samma riktning som en yttre ring) kommer både ST_IsPolygonCW och ST_IsPolygonCCW att returnera false. |
Tillgänglighet: 2.4.0
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder M-koordinater.
ST_IsRing — Testar om en LineString är sluten och enkel.
boolean ST_IsRing(geometry g);
Returns TRUE if this LINESTRING is both ST_IsClosed (ST_StartPoint(g) ~= ST_EndPoint(g)) and ST_IsSimple (does not self intersect).
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. 2.1.5.1
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 7.1.6
![]() | |
SQL-MM definierar att resultatet av |
SELECT ST_IsRing(geom), ST_IsClosed(geom), ST_IsSimple(geom) FROM (SELECT 'LINESTRING(0 0,0 1,1 1,1 0,0 0)'::geometry AS geom) AS foo;
st_isring | st_isclosed | st_issimple -----------+-------------+------------- t | t | t (1 row)
SELECT ST_IsRing(geom), ST_IsClosed(geom), ST_IsSimple(geom) FROM (SELECT 'LINESTRING(0 0,0 1,1 0,1 1,0 0)'::geometry AS geom) AS foo;
st_isring | st_isclosed | st_issimple -----------+-------------+------------- f | t | f (1 row)
ST_IsSimple — Testar om en geometri inte har några punkter med självskärning eller självtangentiering.
boolean ST_IsSimple(geometry geomA);
Returnerar true om denna geometri inte har några avvikande geometriska punkter, t.ex. självskärning eller självtangentiering. Mer information om OGC:s definition av geometrins enkelhet och giltighet finns i "Ensuring OpenGIS compliance of geometries"
![]() | |
SQL-MM definierar att resultatet av ST_IsSimple(NULL) ska vara 0, medan PostGIS returnerar NULL. |
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s2.1.1.1
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.8
Denna funktion stöder 3d och kommer inte att tappa z-index.
SELECT ST_IsSimple('POLYGON((1 2,3 4,5 6,1 2))');f
SELECT ST_IsSimple('LINESTRING(1 1,2 2,2 3.5,1 3,1 2,2 1)');f
ST_M — Returnerar M-koordinaten för en punkt.
float ST_M(geometry a_point);
Returnerar M-koordinaten för en Point, eller NULL om den inte är tillgänglig. Indata måste vara en punkt.
![]() | |
Detta är (ännu) inte en del av OGC-specifikationen, men listas här för att komplettera listan över funktioner för extraktion av punktkoordinater. |
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1.
Denna metod implementerar SQL/MM-specifikationen.
Denna funktion stöder 3d och kommer inte att tappa z-index.
SELECT ST_M('POINT(1 2 3 4)');4
ST_MemSize — Returnerar hur mycket minnesutrymme en geometri tar upp.
integer ST_MemSize(geometry geomA);
Returnerar den mängd minnesutrymme (i byte) som geometrin tar upp.
Detta kompletterar PostgreSQL: s inbyggda databasobjektfunktioner pg_column_size, pg_size_pretty, pg_relation_size, pg_total_relation_size.
![]() | |
pg_relation_size som ger bytestorleken för en tabell kan returnera en bytestorlek som är lägre än ST_MemSize. Detta beror på att pg_relation_size inte lägger till bidrag från toasted-tabeller och att stora geometrier lagras i TOAST-tabeller. pg_total_relation_size - inkluderar tabellen, de toastade tabellerna och indexen. pg_column_size returnerar hur mycket utrymme en geometri skulle ta i en kolumn med hänsyn till komprimering, så det kan vara lägre än ST_MemSize |
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
Ändrad: 2.2.0 namnet ändrat till ST_MemSize för att följa namngivningskonventionen.
Compare the memory used by all geometries in a Massachusetts town dataset with the subset for Boston.
SELECT pg_size_pretty(sum(ST_MemSize(geom))) AS totgeomsum,
pg_size_pretty(sum(CASE WHEN town = 'BOSTON' THEN ST_MemSize(geom) ELSE 0 END)) AS bossum,
cast(
sum(CASE WHEN town = 'BOSTON' THEN ST_MemSize(geom) ELSE 0 END) * 100.0
/ sum(ST_MemSize(geom)) AS numeric(10, 2)
) AS perbos
FROM towns;totgeomsum | bossum | perbos ------------+--------+-------- 1522 kB | 30 kB | 1.99 (1 row)
Return the memory size of a CircularString in bytes.
SELECT ST_MemSize('CIRCULARSTRING(220268 150415,220227 150505,220227 150406)'::geometry);st_memsize
------------
80
(1 row)Calculate the percentage of a table's total size used by geometry data.
SELECT pg_total_relation_size('public.neighborhoods') AS fulltable_size,
sum(ST_MemSize(geom)) AS geomsize,
sum(ST_MemSize(geom)) * 100.0
/ pg_total_relation_size('public.neighborhoods') AS pergeom
FROM neighborhoods;fulltable_size | geomsize | pergeom
----------------+----------+--------------------------
262144 | 96238 | 36.71188354492187500000
(1 row)ST_NDims — Returnerar koordinatdimensionen för en geometri.
integer ST_NDims(geometry g1);
Returnerar geometrins koordinatdimension. PostGIS stöder 2 - (x,y) , 3 - (x,y,z) eller 2D med mått - x,y,m, och 4 - 3D med måttrymd x,y,z,m
Denna funktion stöder 3d och kommer inte att tappa z-index.
SELECT ST_NDims('POINT(1 1)') As d2point,
ST_NDims('POINT(1 1 2)') As d3point,
ST_NDims('POINTM(1 1 0.5)') As d2pointm;d2point | d3point | d2pointm
---------+---------+----------
2 | 3 | 3ST_NPoints — Returnerar antalet punkter (vertices) i en geometri.
integer ST_NPoints(geometry g1);
Returnerar antalet punkter i en geometri. Fungerar för alla geometrier.
Förbättrad: 2.0.0 stöd för polyhedrala ytor infördes.
![]() | |
Före 1.3.4 kraschade den här funktionen om den användes med geometrier som innehåller CURVES. Detta är åtgärdat i 1.3.4+ |
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
Count the points in a 2D LineString.
SELECT ST_NPoints('LINESTRING(77.29 29.07,77.42 29.26,77.27 29.31,77.29 29.07)');st_npoints
------------
4
(1 row)Count the points in a 3D LineString.
SELECT ST_NPoints('LINESTRING(77.29 29.07 1,77.42 29.26 0,77.27 29.31 -1,77.29 29.07 3)');st_npoints
------------
4
(1 row)ST_NRings — Returnerar antalet ringar i en polygonal geometri.
integer ST_NRings(geometry geomA);
Om geometrin är en polygon eller multipolygon returneras antalet ringar. Till skillnad från NumInteriorRings räknar den även de yttre ringarna.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
SELECT ST_NRings(geom) As Nrings, ST_NumInteriorRings(geom) As ninterrings FROM (SELECT 'POLYGON((1 2,3 4,5 6,1 2))'::geometry As geom) As foo;
nrings | ninterrings
--------+-------------
1 | 0
(1 row)ST_NumGeometries — Returnerar antalet element i en geometrisamling.
integer ST_NumGeometries(geometry geom);
Returnerar antalet element i en geometrisamling (GEOMETRYCOLLECTION eller MULTI*). För icke-tomma atomgeometrier returneras 1. För tomma geometrier returneras 0.
Förbättrad: 2.0.0 stöd för polyhedrala ytor, trianglar och TIN infördes.
Ändrad: 2.0.0 I tidigare versioner skulle detta returnera NULL om geometrin inte var en samling/MULTI-typ. 2.0.0+ returnerar nu 1 för enskilda geometrier, t.ex. POLYGON, LINESTRING, POINT.
Changed: 3.6.0 TIN and PolyhedralSurface are treated as unitary geometries and return 1; use ST_NumPatches to count faces.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 9.1.4
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
This example returns 1; prior versions would have returned NULL.
SELECT ST_NumGeometries('LINESTRING(77.29 29.07,77.42 29.26,77.27 29.31,77.29 29.07)');st_numgeometries
------------------
1
(1 row)A MultiPoint counts as one geometry within a GeometryCollection.
SELECT ST_NumGeometries('GEOMETRYCOLLECTION(MULTIPOINT((-2 3),(-2 2)),
LINESTRING(5 5,10 10),
POLYGON((-7 4.2,-7.1 5,-7.1 4.3,-7 4.2)))');st_numgeometries
------------------
3
(1 row)ST_NumInteriorRings — Returnerar antalet inre ringar (hål) i en polygon.
integer ST_NumInteriorRings(geometry a_polygon);
Returnerar antalet inre ringar i en polygongeometri. Returnerar NULL om geometrin inte är en polygon.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 8.2.5
Ändrad: 2.0.0 - i tidigare versioner kunde man skicka en MULTIPOLYGON och få tillbaka antalet inre ringar i den första POLYGONEN.
Count the interior rings of a Polygon.
SELECT gid, field1, field2, ST_NumInteriorRings(geom) AS numholes FROM sometable;
For a MultiPolygon, dump its component Polygons and sum their interior ring counts.
SELECT gid, field1, field2, SUM(ST_NumInteriorRings(geom)) AS numholes
FROM (
SELECT gid, field1, field2, (ST_Dump(geom)).geom AS geom
FROM sometable
) AS foo
GROUP BY gid, field1, field2;
ST_NumInteriorRing — Returns the number of interior rings (holes) of a Polygon. Alias for ST_NumInteriorRings.
integer ST_NumInteriorRing(geometry a_polygon);
ST_NumPatches — Returns the number of faces in a PolyhedralSurface or TIN.
integer ST_NumPatches(geometry g1);
Returns the number of faces in a PolyhedralSurface or TIN. Returns NULL for other geometries. Unlike ST_NumGeometries, this function counts individual faces.
Tillgänglighet: 2.0.0
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM ISO/IEC 13249-3: 8.5
Denna funktion stöder polyedriska ytor.
SELECT ST_NumPatches('POLYHEDRALSURFACE( ((0 0 0,0 0 1,0 1 1,0 1 0,0 0 0)),
((0 0 0,0 1 0,1 1 0,1 0 0,0 0 0)),((0 0 0,1 0 0,1 0 1,0 0 1,0 0 0)),
((1 1 0,1 1 1,1 0 1,1 0 0,1 1 0)),
((0 1 0,0 1 1,1 1 1,1 1 0,0 1 0)),((0 0 1,1 0 1,1 1 1,0 1 1,0 0 1)) )');st_numpatches
---------------
6
(1 row)ST_NumPoints — Returnerar antalet punkter i en LineString eller CircularString.
integer ST_NumPoints(geometry g1);
Returnerar antalet punkter i ett ST_LineString- eller ST_CircularString-värde. Före 1.4 fungerar endast med linestringsar enligt specifikationerna. Från 1.4 och framåt är detta ett alias för ST_NPoints som returnerar antalet hörn för inte bara linestringsar. Överväg att använda ST_NPoints istället som är mångsidigt och fungerar med många geometrityper.
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 7.2.4
SELECT ST_NumPoints('LINESTRING(77.29 29.07,77.42 29.26,77.27 29.31,77.29 29.07)');st_numpoints
--------------
4
(1 row)ST_PatchN — Returns the Nth face of a PolyhedralSurface or TIN.
geometry ST_PatchN(geometry geomA, integer n);
Returns the 1-based Nth face of a PolyhedralSurface or TIN. Returns NULL for other geometries or an out-of-range index. Use this function to access faces, because ST_GeometryN treats PolyhedralSurface and TIN as unitary geometries.
![]() | |
Index är 1-baserat. |
![]() | |
Om du vill extrahera alla element i en geometri är ST_Dump mer effektivt. |
Tillgänglighet: 2.0.0
Denna metod implementerar SQL/MM-specifikationen. SQL-MM ISO/IEC 13249-3: 8.5
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
Extract the 2nd face of the polyhedral surface.
SELECT ST_PatchN(geom, 2) As geomewkt
FROM (
VALUES ('POLYHEDRALSURFACE( ((0 0 0,0 0 1,0 1 1,0 1 0,0 0 0)),
((0 0 0,0 1 0,1 1 0,1 0 0,0 0 0)),((0 0 0,1 0 0,1 0 1,0 0 1,0 0 0)),
((1 1 0,1 1 1,1 0 1,1 0 0,1 1 0)),
((0 1 0,0 1 1,1 1 1,1 1 0,0 1 0)),((0 0 1,1 0 1,1 1 1,0 1 1,0 0 1)) )'::geometry) ) As foo(geom);POLYGON((0 0 0,0 1 0,1 1 0,1 0 0,0 0 0))
ST_PointN — Returnerar den N:te punkten i den första LineString eller cirkulära LineString i en geometri.
geometry ST_PointN(geometry a_linestring, integer n);
Returnerar den N:te punkten i en enkel linestrings eller cirkulär linestrings i geometrin. Negativa värden räknas baklänges från slutet av LineString, så att -1 är den sista punkten. Returnerar NULL om det inte finns någon linestrings i geometrin.
![]() | |
Index is 1-based as for OGC specs since version 0.8.0. Backward indexing (negative index) is not in OGC. Previous versions implemented this as 0-based instead. |
![]() | |
Om du vill få fram den N:te punkten i varje LineString i en MultiLineString, använd tillsammans med ST_Dump |
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 7.2.5, 7.3.5
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
Ändrad: 2.0.0 fungerar inte längre med multilinestrings med en geometri. I äldre versioner av PostGIS -- skulle en multilinestring med en enda linje fungera bra med den här funktionen och returnera startpunkten. I 2.0.0 returnerar den bara NULL som vilken annan multilinjesträng som helst.
Ändrad: 2.3.0 : negativ indexering tillgänglig (-1 är sista punkten)
This example extracts all POINT geometries from a LineString.
SELECT ST_PointN(
column1,
generate_series(1, ST_NPoints(column1))
)
FROM ( VALUES ('LINESTRING(0 0,1 1,2 2)'::geometry) ) AS foo;POINT(0 0) POINT(1 1) POINT(2 2) (3 rows)
This example uses a CircularString.
SELECT ST_PointN('CIRCULARSTRING(1 2,3 2,1 2)', 2);POINT(3 2)
The index is 1-based. A negative index counts backward from the end of the LineString.
SELECT f
FROM ST_GeomFromText('LINESTRING(0 0 0,1 1 1,2 2 2)') AS g
CROSS JOIN ST_PointN(g, -2) AS f;POINT Z (1 1 1)
ST_Points — Returnerar en MultiPoint som innehåller koordinaterna för en geometri.
geometry ST_Points( geometry geom );
Returnerar en MultiPoint som innehåller alla koordinater för en geometri. Duplicerade punkter bevaras, inklusive start- och slutpunkterna för ringgeometrier. (Om så önskas kan duplicerade punkter tas bort genom att anropa ST_RemoveRepeatedPoints på resultatet).
För att få information om varje koordinats position i den överordnade geometrin använder du ST_DumpPoints.
M- och Z-koordinater bevaras om de finns.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Tillgänglighet: 2.3.0
SELECT ST_Points('POLYGON Z ((30 10 4,10 30 5,40 40 6,30 10 4))');MULTIPOINT Z ((30 10 4),(10 30 5),(40 40 6),(30 10 4))
ST_StartPoint — Returns the first point of a LineString, CircularLineString, or NURBSCurve.
geometry ST_StartPoint(geometry geomA);
Returns the first point of a LINESTRING, CIRCULARLINESTRING, or NURBSCURVE geometry as a POINT. For other geometries, returns the first point in coordinate order.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 7.1.3
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
Förbättrad: 3.2.0 returnerar en punkt för alla geometrier. Tidigare beteende returnerade NULL om indata inte var en LineString.
Ändrad: 2.0.0 fungerar inte längre med MultiLineStrings med en geometri. I äldre versioner av PostGIS skulle en MultiLineString med en enda rad fungera bra med den här funktionen och returnera startpunkten. I 2.0.0 returnerar den bara NULL som vilken annan MultiLineString som helst. Det gamla beteendet var en odokumenterad funktion, men personer som antog att de hade sina data lagrade som LINESTRING kan uppleva att dessa returnerar NULL i 2.0.0.
Startpunkt för en LineString
SELECT ST_StartPoint('LINESTRING(0 1,0 2)'::geometry);POINT(0 1)
Start point of a Point is the Point itself
SELECT ST_StartPoint('POINT(0 1)'::geometry);POINT(0 1)
Startpunkt för en 3D-linjeString
SELECT ST_StartPoint('LINESTRING(0 1 1,0 2 2)'::geometry);POINT(0 1 1)
Startpunkt för en CircularString
SELECT ST_StartPoint('CIRCULARSTRING(5 2,-3 2,-2 1,-4 2,6 3)'::geometry);POINT(5 2)
Start point of a NURBSCurve
SELECT ST_StartPoint('NURBSCURVE(2, (0 0, 1 1, 2 0))'::geometry);PUNKT(0 0)
Build edge node references from the start and end points of a LineString table. The example uses exact endpoint equality, so linework with nearly coincident endpoints should be snapped or otherwise cleaned first.
WITH roads(road_id, geom) AS (
VALUES
(1, 'LINESTRING(0 0, 1 0)'::geometry),
(2, 'LINESTRING(1 0, 1 1)'::geometry),
(3, 'LINESTRING(1 0, 2 0)'::geometry)
),
endpoints AS (
SELECT road_id, 'from' AS end_name, ST_StartPoint(geom) AS geom,
ST_AsEWKB(ST_StartPoint(geom)) AS endpoint_key
FROM roads
UNION ALL
SELECT road_id, 'to' AS end_name, ST_EndPoint(geom) AS geom,
ST_AsEWKB(ST_EndPoint(geom)) AS endpoint_key
FROM roads
),
nodes AS (
SELECT dense_rank() OVER (ORDER BY ST_X(geom), ST_Y(geom), endpoint_key) AS node_id,
endpoint_key
FROM (
SELECT DISTINCT ON (endpoint_key) endpoint_key, geom
FROM endpoints
ORDER BY endpoint_key
) AS distinct_endpoints
)
SELECT e.road_id,
max(n.node_id) FILTER (WHERE e.end_name = 'from') AS from_node,
max(n.node_id) FILTER (WHERE e.end_name = 'to') AS to_node
FROM endpoints AS e
JOIN nodes AS n USING (endpoint_key)
GROUP BY e.road_id
ORDER BY e.road_id;road_id | from_node | to_node
---------+-----------+---------
1 | 1 | 2
2 | 2 | 3
3 | 2 | 4ST_StartM — Returns the M coordinate of the first point of a LineString, CircularLineString, or NURBSCurve.
float8 ST_StartM(geometry geom);
Returns the M coordinate of the first point of a LINESTRING, CIRCULARLINESTRING, or NURBSCURVE geometry. Returns NULL if the input geometry does not have an M dimension or is not a LINESTRING, CIRCULARLINESTRING, or NURBSCURVE.
Denna metod stöder cirkulära strängar och kurvor.
Start M value of a LineString
SELECT ST_StartM('LINESTRING M(0 0 10,1 1 20,2 0 30)'::geometry);10
Start M value of a CircularString
SELECT ST_StartM('CIRCULARSTRING M(0 0 5,1 1 10,2 0 15)'::geometry);5
Start M value of a NURBSCurve
SELECT ST_StartM('NURBSCURVE M(2, (0 0 100, 1 1 200, 2 0 300))'::geometry);100
Geometry without M dimension returns NULL
SELECT ST_StartM('LINESTRING(0 0,1 1)'::geometry) IS NULL AS is_null;t
ST_EndM — Returns the M coordinate of the last point of a LineString, CircularLineString, or NURBSCurve.
float8 ST_EndM(geometry geom);
Returns the M coordinate of the last point of a LINESTRING, CIRCULARLINESTRING, or NURBSCURVE geometry. Returns NULL if the input geometry does not have an M dimension or is not a LINESTRING, CIRCULARLINESTRING, or NURBSCURVE.
Denna metod stöder cirkulära strängar och kurvor.
End M value of a LineString
SELECT ST_EndM('LINESTRING M(0 0 10,1 1 20,2 0 30)'::geometry);30
End M value of a CircularString
SELECT ST_EndM('CIRCULARSTRING M(0 0 5,1 1 10,2 0 15)'::geometry);15
End M value of a NURBSCurve
SELECT ST_EndM('NURBSCURVE M(2, (0 0 100, 1 1 200, 2 0 300))'::geometry);300
Geometry without M dimension returns NULL
SELECT ST_EndM('LINESTRING(0 0,1 1)'::geometry) IS NULL AS is_null;t
ST_SetStartM — Sets the M coordinate of the first point of a LineString, CircularLineString, or NURBSCurve.
geometry ST_SetStartM(geometry geom, float8 m);
Returns a copy of the input LINESTRING, CIRCULARLINESTRING, or NURBSCURVE geometry with the M coordinate of the first point set to the specified value. If the input geometry does not have an M dimension, it will be added. Returns NULL if the input is not a LINESTRING, CIRCULARLINESTRING, or NURBSCURVE.
Denna metod stöder cirkulära strängar och kurvor.
Set start M value of a LineString
SELECT ST_SetStartM('LINESTRING M(0 0 10,1 1 20,2 0 30)'::geometry, 100);LINESTRING M (0 0 100,1 1 20,2 0 30)
Add M dimension and set start M value
SELECT ST_SetStartM('LINESTRING(0 0,1 1,2 0)'::geometry, 50);LINESTRING M (0 0 50,1 1 0,2 0 0)
Set start M value of a CircularString
SELECT ST_SetStartM('CIRCULARSTRING M(0 0 5,1 1 10,2 0 15)'::geometry, 99);CIRCULARSTRING M (0 0 99,1 1 10,2 0 15)
Set start M value of a NURBSCurve
SELECT ST_SetStartM('NURBSCURVE M(2, (0 0 100, 1 1 200, 2 0 300))'::geometry, 500);NURBSCURVE M (DEGREE 2,CONTROLPOINTS M (NURBSPOINT(WEIGHTEDPOINT M (0 0 500),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT M (1 1 200),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT M (2 0 300),WEIGHT 1)),KNOTS (KNOT(0,3), KNOT(1,3)))
ST_SetEndM — Sets the M coordinate of the last point of a LineString, CircularLineString, or NURBSCurve.
geometry ST_SetEndM(geometry geom, float8 m);
Returns a copy of the input LINESTRING, CIRCULARLINESTRING, or NURBSCURVE geometry with the M coordinate of the last point set to the specified value. If the input geometry does not have an M dimension, it will be added. Returns NULL if the input is not a LINESTRING, CIRCULARLINESTRING, or NURBSCURVE.
Denna metod stöder cirkulära strängar och kurvor.
Set end M value of a LineString
SELECT ST_SetEndM('LINESTRING M(0 0 10,1 1 20,2 0 30)'::geometry, 999);LINESTRING M (0 0 10,1 1 20,2 0 999)
Add M dimension and set end M value
SELECT ST_SetEndM('LINESTRING(0 0,1 1,2 0)'::geometry, 75);LINESTRING M (0 0 0,1 1 0,2 0 75)
Set end M value of a CircularString
SELECT ST_SetEndM('CIRCULARSTRING M(0 0 5,1 1 10,2 0 15)'::geometry, 88);CIRCULARSTRING M (0 0 5,1 1 10,2 0 88)
Set end M value of a NURBSCurve
SELECT ST_SetEndM('NURBSCURVE M(2, (0 0 100, 1 1 200, 2 0 300))'::geometry, 999);NURBSCURVE M (DEGREE 2,CONTROLPOINTS M (NURBSPOINT(WEIGHTEDPOINT M (0 0 100),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT M (1 1 200),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT M (2 0 999),WEIGHT 1)),KNOTS (KNOT(0,3), KNOT(1,3)))
ST_Summary — Returnerar en textsammanfattning av innehållet i en geometri.
text ST_Summary(geometry g);
text ST_Summary(geography g);
Returnerar en textsammanfattning av innehållet i geometrin.
Flaggor som visas inom hakparentes efter geometritypen har följande betydelse:
M: har M-koordinat
Z: har Z-koordinat
B: har en cachad avgränsande box
G: är geodetisk (geografi)
S: har ett spatialt referenssystem
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
Tillgänglighet: 1.2.2
Förbättrad: 2.0.0 har lagt till stöd för geografi
Utökad: 2.1.0 S-flagga för att ange om det finns ett känt spatialt referenssystem
Förbättrad: 2.2.0 Lagt till stöd för TIN och kurvor
SELECT ST_Summary('LINESTRING(0 0,1 1)'::geometry) as geom,
ST_Summary('POLYGON((0 0,1 1,1 2,1 1,0 0))'::geography) geog;geom | geog
-----------------------------+--------------------------
LineString[B] with 2 points | Polygon[BGS] with 1 rings
| ring 0 has 5 points
:
(1 row)SELECT ST_Summary('LINESTRING(0 0 1,1 1 1)'::geography) As geog_line,
ST_Summary('SRID=4326;POLYGON((0 0 1,1 1 2,1 2 3,1 1 1,0 0 1))'::geometry) As geom_poly;geog_line | geom_poly
-------------------------------- +--------------------------
LineString[ZBGS] with 2 points | Polygon[ZBS] with 1 rings
: ring 0 has 5 points
:
(1 row)ST_X — Returnerar X-koordinaten för en Point.
float ST_X(geometry a_point);
Returnerar punktens X-koordinat, eller NULL om den inte är tillgänglig. Indata måste vara en punkt.
![]() | |
För att få det minsta och största X-värdet för geometriska koordinater använder du funktionerna ST_XMin och ST_XMax. |
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 6.1.3
Denna funktion stöder 3d och kommer inte att tappa z-index.
SELECT ST_X('POINT(1 2 3 4)');1
SELECT ST_Y(ST_Centroid('LINESTRING(1 2 3 4,1 1 1 1)'::geometry));1.5
ST_Centroid, ST_GeomFromEWKT, ST_M, ST_XMax, ST_XMin, ST_Y, ST_Z
ST_Y — Returnerar Y-koordinaten för en Point.
float ST_Y(geometry a_point);
Returnerar punktens Y-koordinat, eller NULL om den inte är tillgänglig. Indata måste vara en punkt.
![]() | |
För att få det lägsta och högsta Y-värdet för geometriska koordinater använder du funktionerna ST_YMin och ST_YMax. |
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 6.1.4
Denna funktion stöder 3d och kommer inte att tappa z-index.
SELECT ST_Y('POINT(1 2 3 4)');2
SELECT ST_Y(ST_Centroid('LINESTRING(1 2 3 4,1 1 1 1)'::geometry));1.5
ST_Centroid, ST_GeomFromEWKT, ST_M, ST_X, ST_YMax, ST_YMin, ST_Z
ST_Z — Returnerar Z-koordinaten för en Point.
float ST_Z(geometry a_point);
Returnerar punktens Z-koordinat, eller NULL om den inte är tillgänglig. Indata måste vara en punkt.
![]() | |
För att få det lägsta och högsta Z-värdet för geometriska koordinater använder du funktionerna ST_ZMin och ST_ZMax. |
Denna metod implementerar SQL/MM-specifikationen.
Denna funktion stöder 3d och kommer inte att tappa z-index.
SELECT ST_Z('POINT(1 2 3 4)');3
ST_ZMFlag — Returnerar en kod som anger ZM-koordinatdimensionen för en geometri.
smallint ST_ZMFlag(geometry geomA);
Returnerar en kod som anger ZM-koordinatdimensionen för en geometri.
Värdena är: 0 = 2D, 1 = 3D-M, 2 = 3D-Z, 3 = 4D.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
SELECT ST_ZMFlag('LINESTRING(1 2,3 4)');0
SELECT ST_ZMFlag('LINESTRINGM(1 2 3, 3 4 3)');1
SELECT ST_ZMFlag('CIRCULARSTRING(1 2 3,3 4 3,5 6 3)');2
SELECT ST_ZMFlag('POINT(1 2 3 4)');3
ST_HasZ — Kontrollerar om en geometri har en Z-dimension.
boolean ST_HasZ(geometry geom);
Kontrollerar om indatageometrin har en Z-dimension och returnerar ett booleskt värde. Om geometrin har en Z-dimension returneras true, annars returneras false.
Geometriobjekt med en Z-dimension representerar vanligtvis tredimensionella (3D) geometrier, medan de utan Z-dimension är tvådimensionella (2D) geometrier.
Denna funktion är användbar för att avgöra om en geometri har höjdinformation.
Tillgänglighet: 3.5.0
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder M-koordinater.
SELECT ST_HasZ('POINT(1 2 3)');t
SELECT ST_HasZ('LINESTRING(0 0,1 1)');f
ST_HasM — Kontrollerar om en geometri har en M (mått)-dimension.
boolean ST_HasM(geometry geom);
Kontrollerar om indatageometrin har en M-dimension (mått) och returnerar ett booleskt värde. Om geometrin har en M-dimension returnerar den true, annars returnerar den false.
Geometriobjekt med en M-dimension representerar vanligtvis mätningar eller ytterligare data som är associerade med spatiala egenskaper.
Denna funktion är användbar för att avgöra om en geometri innehåller måttinformation.
Tillgänglighet: 3.5.0
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder M-koordinater.
SELECT ST_HasM('POINTM(1 2 3)');t
SELECT ST_HasM('LINESTRING(0 0,1 1)');f
ST_ControlPoints — Returns the control points of a NURBS curve as a MULTIPOINT geometry.
geometry ST_ControlPoints(geometry nurbscurve);
Extracts the control points from a NURBS curve and returns them as a MULTIPOINT geometry. Control points define the control polygon that influences the shape of the NURBS curve.
The function raises an error if the input is not a NURBS curve. Returns NULL if the input is NULL.
Availability: 3.7.0
This example extracts control points from a NURBS curve.
SELECT ST_ControlPoints('NURBSCURVE(2, (0 0, 5 10, 10 0))'::geometry);MULTIPOINT((0 0),(5 10),(10 0))
This example counts the control points.
SELECT ST_NPoints(ST_ControlPoints('NURBSCURVE(2, (0 0, 5 10, 10 0))'::geometry));3
ST_Degree — Returns the polynomial degree of a NURBS curve.
integer ST_Degree(geometry nurbscurve);
Returns the polynomial degree of a NURBS curve as an integer. The degree determines the curve's smoothness and flexibility. Higher degrees produce smoother curves but require more control points.
The function raises an error if the input is not a NURBS curve. Returns NULL if the input is NULL.
Availability: 3.7.0
This example returns the degree of a NURBS curve.
SELECT ST_Degree('NURBSCURVE(2, (0 0, 5 10, 10 0))'::geometry);2
This example checks whether a NURBS curve is cubic.
SELECT ST_Degree('NURBSCURVE(3, (0 0, 2 5, 5 8, 10 0))'::geometry) = 3;t
ST_Weights — Returns the weight array of a rational NURBS curve.
float8[] ST_Weights(geometry nurbscurve);
Returns the weight values of a rational NURBS curve as an array of double precision values. Weights control the influence of each control point on the curve shape. Higher weights pull the curve closer to the corresponding control point.
Returns NULL if the curve has no weights (non-rational B-spline) or if the input is NULL. Raises an error if the input is not a NURBS curve.
Availability: 3.7.0
This example returns weights from a rational NURBS curve.
SELECT ST_Weights(ST_MakeNurbsCurve(2, 'LINESTRING(0 0,5 10,10 0)'::geometry, ARRAY[1.0, 2.0, 1.0]));
{1,2,1}This example checks the weights of a non-rational curve.
SELECT ST_Weights('NURBSCURVE(2, (0 0, 5 10, 10 0))'::geometry);null
ST_Knots — Returns the knot vector of a NURBS curve.
float8[] ST_Knots(geometry nurbscurve);
Returns the knot vector of a NURBS curve as an array of double precision values. The knot vector defines the parameter space and controls where and how the control points affect the curve. It must be a non-decreasing sequence with length equal to (number of control points + degree + 1).
Returns NULL if the curve uses the default uniform clamped knot vector or if the input is NULL. Raises an error if the input is not a NURBS curve.
Availability: 3.7.0
This example returns knots from a NURBS curve with a custom knot vector.
SELECT ST_Knots(ST_MakeNurbsCurve(
2,
'LINESTRING(0 0,5 10,10 0)'::geometry,
ARRAY[1.0, 2.0, 1.0],
ARRAY[0, 0, 0, 1, 1, 1]));{0,0,0,1,1,1}This example checks the knots of a curve using the default knot vector.
SELECT ST_Knots('NURBSCURVE(2, (0 0, 5 10, 10 0))'::geometry);null
ST_NumControlPoints — Returns the number of control points in a NURBS curve.
integer ST_NumControlPoints(geometry nurbscurve);
Returns the number of control points in a NURBS curve. The number of control points must be at least (degree + 1) for a valid NURBS curve.
Raises an error if the input is not a NURBS curve. Returns NULL if the input is NULL.
Availability: 3.7.0
This example returns the number of control points.
SELECT ST_NumControlPoints('NURBSCURVE(2, (0 0, 5 10, 10 0))'::geometry);3
This example verifies that a curve has enough control points for its degree.
SELECT ST_NumControlPoints(curve) >= ST_Degree(curve) + 1 AS valid FROM (SELECT 'NURBSCURVE(2, (0 0, 5 10, 10 0))'::geometry AS curve) AS t;
t
ST_NurbsCurveIsRational — Checks if a NURBS curve is rational (has weights).
boolean ST_NurbsCurveIsRational(geometry nurbscurve);
Returns TRUE if the NURBS curve has weights assigned to its control points (rational NURBS), FALSE if it uses uniform weights (non-rational B-spline).
Rational NURBS curves provide more flexibility in curve shape control through variable weights. Non-rational B-splines use uniform weights and are a special case of NURBS curves.
Raises an error if the input is not a NURBS curve. Returns NULL if the input is NULL.
Availability: 3.7.0
This example checks whether a curve is rational.
SELECT ST_NurbsCurveIsRational(ST_MakeNurbsCurve(
2,
'LINESTRING(0 0,5 10,10 0)'::geometry,
ARRAY[1.0, 2.0, 1.0]));t
This example checks a non-rational curve.
SELECT ST_NurbsCurveIsRational('NURBSCURVE(2, (0 0, 5 10, 10 0))'::geometry);f
ST_IsNurbsCurve — Checks if a geometry is a NURBS curve.
boolean ST_IsNurbsCurve(geometry geom);
Returns TRUE if the geometry is a NURBS curve, FALSE otherwise. This function can be used to test geometry types before applying NURBS-specific functions.
Returns NULL if the input is NULL.
Availability: 3.7.0
This example checks whether a geometry is a NURBS curve.
SELECT ST_IsNurbsCurve('NURBSCURVE(2, (0 0, 5 10, 10 0))'::geometry);t
This example tests a regular LineString.
SELECT ST_IsNurbsCurve('LINESTRING(0 0,10 10)'::geometry);f
ST_Evaluate — Evaluates a NURBS curve at a specific parameter value and returns the resulting point.
geometry ST_Evaluate(geometry nurbscurve, float8 parameter);
Evaluates a NURBS curve at the specified parameter value and returns a POINT geometry representing the position on the curve. The parameter typically ranges from 0.0 (start of curve) to 1.0 (end of curve), though the actual range depends on the knot vector.
Raises an error if the input is not a NURBS curve or if evaluation fails. Returns NULL if either input is NULL.
Availability: 3.7.0
This example returns the midpoint of a NURBS curve.
SELECT ST_Evaluate('NURBSCURVE(2, (0 0, 5 10, 10 0))'::geometry, 0.5);This example samples multiple points along a curve.
SELECT t, ST_Evaluate(curve, t) AS point
FROM (SELECT 'NURBSCURVE(2, (0 0, 5 10, 10 0))'::geometry AS curve) AS c,
generate_series(0, 1, 0.25) AS t;ST_NurbsToLineString — Converts a NURBS curve to a LINESTRING by uniform sampling.
geometry ST_NurbsToLineString(geometry nurbscurve, integer num_segments=32);
Converts a NURBS curve to a LINESTRING geometry by creating a piecewise linear approximation. The curve is sampled at uniformly distributed parameter values and the resulting points are connected with straight line segments.
The optional num_segments parameter specifies the number of line segments in the output (default: 32, range: 2-10000). Higher values produce smoother approximations but increase geometry complexity.
Raises an error if the input is not a NURBS curve. Returns NULL if the input is NULL.
Availability: 3.7.0
This example converts a NURBS curve to a LineString using the default quality.
SELECT ST_NurbsToLineString('NURBSCURVE(2, (0 0, 5 10, 10 0))'::geometry);LINESTRING(0 0,0.3125 0.60546875,0.625 1.171875,0.9375 1.69921875,1.25 2.1875,1.5625 2.63671875,1.875 3.046875,2.1875 3.41796875,2.5 3.75,2.8125 4.04296875,3.125 4.296875,3.4375 4.51171875,3.75 4.6875,4.0625 4.82421875,4.375 4.921875,4.6875 4.98046875,5 5,5.3125 4.98046875,5.625 4.921875,5.9375 4.82421875,6.25 4.6875,6.5625 4.51171875,6.875 4.296875,7.1875 4.04296875,7.5 3.75,7.8125 3.41796875,8.125 3.046875,8.4375 2.63671875,8.75 2.1875,9.0625 1.69921875,9.375 1.171875,9.6875 0.60546875,10 0)
This example creates a high-quality approximation with 64 segments.
SELECT ST_NurbsToLineString('NURBSCURVE(2, (0 0, 5 10, 10 0))'::geometry, 64);LINESTRING(0 0,0.15625 0.3076171875,0.3125 0.60546875,0.46875 0.8935546875,0.625 1.171875,0.78125 1.4404296875,0.9375 1.69921875,1.09375 1.9482421875,1.25 2.1875,1.40625 2.4169921875,1.5625 2.63671875,1.71875 2.8466796875,1.875 3.046875,2.03125 3.2373046875,2.1875 3.41796875,2.34375 3.5888671875,2.5 3.75,2.65625 3.9013671875,2.8125 4.04296875,2.96875 4.1748046875,3.125 4.296875,3.28125 4.4091796875,3.4375 4.51171875,3.59375 4.6044921875,3.75 4.6875,3.90625 4.7607421875,4.0625 4.82421875,4.21875 4.8779296875,4.375 4.921875,4.53125 4.9560546875,4.6875 4.98046875,4.84375 4.9951171875,5 5,5.15625 4.9951171875,5.3125 4.98046875,5.46875 4.9560546875,5.625 4.921875,5.78125 4.8779296875,5.9375 4.82421875,6.09375 4.7607421875,6.25 4.6875,6.40625 4.6044921875,6.5625 4.51171875,6.71875 4.4091796875,6.875 4.296875,7.03125 4.1748046875,7.1875 4.04296875,7.34375 3.9013671875,7.5 3.75,7.65625 3.5888671875,7.8125 3.41796875,7.96875 3.2373046875,8.125 3.046875,8.28125 2.8466796875,8.4375 2.63671875,8.59375 2.4169921875,8.75 2.1875,8.90625 1.9482421875,9.0625 1.69921875,9.21875 1.4404296875,9.375 1.171875,9.53125 0.8935546875,9.6875 0.60546875,9.84375 0.3076171875,10 0)
This example creates a lower-quality, faster approximation with 16 segments.
SELECT ST_NurbsToLineString('NURBSCURVE(2, (0 0, 5 10, 10 0))'::geometry, 16);LINESTRING(0 0,0.625 1.171875,1.25 2.1875,1.875 3.046875,2.5 3.75,3.125 4.296875,3.75 4.6875,4.375 4.921875,5 5,5.625 4.921875,6.25 4.6875,6.875 4.296875,7.5 3.75,8.125 3.046875,8.75 2.1875,9.375 1.171875,10 0)
Dessa funktioner skapar modifierade geometrier genom att ändra typ, struktur eller hörn.
ST_AddPoint — Lägg till en punkt i en LineString.
geometry ST_AddPoint(geometry linestring, geometry point);
geometry ST_AddPoint(geometry linestring, geometry point, integer position = -1);
Lägger till en punkt till en LineString före indexpositionen (med ett 0-baserat index). Om positionsparametern utelämnas eller är -1 läggs punkten till i slutet av LineString.
Tillgänglighet: 1.1.0
Denna funktion stöder 3d och kommer inte att tappa z-index.
Lägg till en punkt i slutet av en 3D-linje
SELECT ST_AddPoint('LINESTRING(0 0 1,1 1 1)', ST_MakePoint(1, 2, 3));LINESTRING(0 0 1,1 1 1,1 2 3)
Garantera att alla rader i en tabell är slutna genom att lägga till startpunkten för varje rad till slutet av raden endast för de rader som inte är slutna.
UPDATE sometable SET geom = ST_AddPoint(geom, ST_StartPoint(geom)) FROM sometable WHERE ST_IsClosed(geom) = false;
ST_CollectionExtract — Ger en geometrisamling och returnerar en multigeometri som endast innehåller element av en angiven typ.
geometry ST_CollectionExtract(geometry collection);
geometry ST_CollectionExtract(geometry collection, integer type);
Ger en geometrisamling och returnerar en homogen multigeometri.
Om typen inte anges returneras en multigeometri som endast innehåller geometrier med den högsta dimensionen. Polygoner är alltså att föredra framför linjer, som i sin tur är att föredra framför punkter.
Om typen anges, returneras en multigeometri som endast innehåller den typen. Om det inte finns några subgeometrier av rätt typ returneras en EMPTY geometri. Endast punkter, linjer och polygoner stöds. Typnumren är:
1 == PUNKT
2 == LINESTRING
3 == POLYGON
För inmatningar med atomär geometri returneras geometrin oförändrad om inmatningstypen matchar den begärda typen. I annat fall är resultatet en EMPTY-geometri av den angivna typen. Om så krävs kan dessa konverteras till multi-geometrier med ST_Multi.
![]() | |
MultiPolygon-resultat kontrolleras inte med avseende på giltighet. Om polygonkomponenterna är angränsande eller överlappande blir resultatet ogiltigt. (Detta kan t.ex. inträffa när denna funktion används på ett resultat från ST_Split.) Denna situation kan kontrolleras med ST_IsValid och repareras med ST_MakeValid. |
Tillgänglighet: 1.5.0
![]() | |
Före 1.5.3 returnerade denna funktion atomära indata oförändrade, oavsett typ. I 1.5.3 returnerade icke-matchande singelgeometrier ett NULL-resultat. I 2.0.0 returnerar icke-matchande enskilda geometrier ett EMPTY-resultat av den begärda typen. |
Extrahera typ med högsta dimension:
SELECT ST_CollectionExtract('GEOMETRYCOLLECTION( POINT(0 0), LINESTRING(1 1,2 2) )');MULTILINESTRING((1 1, 2 2))
Extrahera punkter (typ 1 == POINT):
SELECT ST_CollectionExtract('GEOMETRYCOLLECTION(GEOMETRYCOLLECTION(POINT(0 0)))',
1);MULTIPOINT((0 0))
Extrahera linjer (typ 2 == LINESTRING):
SELECT ST_CollectionExtract('GEOMETRYCOLLECTION(GEOMETRYCOLLECTION(LINESTRING(0 0,1 1)), LINESTRING(2 2,3 3))',
2);MULTILINESTRING((0 0, 1 1), (2 2, 3 3))
ST_CollectionHomogenize — Returnerar den enklaste representationen av en geometrisamling.
geometry ST_CollectionHomogenize(geometry collection);
Ger en geometrisamling och returnerar den "enklaste" representationen av innehållet.
Homogena (enhetliga) samlingar returneras som lämplig multigeometri.
Heterogena (blandade) samlingar plattas ut till en enda GeometryCollection.
Samlingar som innehåller ett enda atomärt element returneras som det elementet.
Atomgeometrier returneras oförändrade. Om så krävs kan dessa konverteras till en multigeometri med hjälp av ST_Multi.
![]() | |
Denna funktion garanterar inte att resultatet är giltigt. I synnerhet kommer en samling som innehåller intilliggande eller överlappande polygoner att skapa en ogiltig MultiPolygon. Denna situation kan kontrolleras med ST_IsValid och repareras med ST_MakeValid. |
Tillgänglighet: 2.0.0
Samling med ett enda element omvandlad till en atomär geometri
SELECT ST_CollectionHomogenize('GEOMETRYCOLLECTION(POINT(0 0))');PUNKT(0 0)
Nästlad samling av enskilda element konverterad till en atomär geometri:
SELECT ST_CollectionHomogenize('GEOMETRYCOLLECTION(MULTIPOINT((0 0)))');PUNKT(0 0)
Samling omvandlad till en multigeometri:
SELECT ST_CollectionHomogenize('GEOMETRYCOLLECTION(POINT(0 0), POINT(1 1))');MULTIPOINT((0 0),(1 1))
Nästlad heterogen samling som plattats ut till en GeometryCollection:
SELECT ST_CollectionHomogenize('GEOMETRYCOLLECTION(POINT(0 0), GEOMETRYCOLLECTION( LINESTRING(1 1,2 2)))');GEOMETRYCOLLECTION(POINT(0 0), LINESTRING(1 1,2 2))
Samling av polygoner som konverterats till en (ogiltig) MultiPolygon:
SELECT ST_CollectionHomogenize('GEOMETRYCOLLECTION (POLYGON ((10 50,50 50,50 10,10 10,10 50)),POLYGON ((90 50,90 10,50 10,50 50,90 50)))');MULTIPOLYGON(((10 50,50 50,50 10,10 10,10 50)),((90 50,90 10,50 10,50 50,90 50)))
ST_CurveToLine — Konverterar en geometri som innehåller kurvor till en linjär geometri.
geometry ST_CurveToLine(geometry curveGeom, float tolerance, integer tolerance_type, integer flags);
Konverterar en CIRCULAR STRING till vanlig LINESTRING eller CURVEPOLYGON till POLYGON eller MULTISURFACE till MULTIPOLYGON. Användbart för utdata till enheter som inte stöder geometrityper av typen CIRCULARSTRING
Konverterar en given geometri till en linjär geometri. Varje krökt geometri eller segment konverteras till en linjär approximation med hjälp av den angivna `toleransen` och alternativen (32 segment per kvadrant och inga alternativ som standard).
Argumentet "tolerance_type" bestämmer tolkningen av argumentet "tolerance". Det kan anta följande värden:
0 (standard): Toleransen är max segment per kvadrant.
1: Tolerans är max-avvikelse för linjen från kurvan, i källenheter.
2: Toleransen är maxvinkeln, i radianer, mellan genereringsradierna.
Argumentet "flags" är ett bitfält. 0 som standard. Bitar som stöds är:
1: Symmetrisk (orienteringsoberoende) utdata.
2: Behåll vinkeln, undviker att minska vinklar (segmentlängder) när symmetrisk utdata produceras. Har ingen effekt när Symmetric-flaggan är avstängd.
Tillgänglighet: 1.3.0
Förbättrad: I 2.4.0 tillkom stöd för toleranserna max-avvikelse och max-vinkel samt för symmetrisk utdata.
Förbättrad: 3.0.0 implementerade ett minsta antal segment per linjäriserad båge för att förhindra topologisk kollaps.
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 7.1.7
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
SELECT ST_CurveToLine('CIRCULARSTRING(220268 150415,220227 150505,220227 150406)');LINESTRING(220268 150415,220269.95064912 150416.539364228,220271.823415575 150418.17258804,220273.613787707 150419.895736857, 220275.317452352 150421.704659462,220276.930305234 150423.594998003,220278.448460847 150425.562198489, 220279.868261823 150427.60152176,220281.186287736 150429.708054909,220282.399363347 150431.876723113, 220283.50456625 150434.10230186,220284.499233914 150436.379429536,220285.380970099 150438.702620341,220286.147650624 150441.066277505, 220286.797428488 150443.464706771,220287.328738321 150445.892130112,220287.740300149 150448.342699654, 220288.031122486 150450.810511759,220288.200504713 150453.289621251,220288.248038775 150455.77405574, 220288.173610157 150458.257830005,220287.977398166 150460.734960415,220287.659875492 150463.199479347, 220287.221807076 150465.64544956,220286.664248262 150468.066978495,220285.988542259 150470.458232479,220285.196316903 150472.81345077, 220284.289480732 150475.126959442,220283.270218395 150477.39318505,220282.140985384 150479.606668057, 220280.90450212 150481.762075989,220279.5637474 150483.85421628,220278.12195122 150485.87804878, 220276.582586992 150487.828697901,220274.949363179 150489.701464356,220273.226214362 150491.491836488, 220271.417291757 150493.195501133,220269.526953216 150494.808354014,220267.559752731 150496.326509628, 220265.520429459 150497.746310603,220263.41389631 150499.064336517,220261.245228106 150500.277412127, 220259.019649359 150501.38261503,220256.742521683 150502.377282695,220254.419330878 150503.259018879, 220252.055673714 150504.025699404,220249.657244448 150504.675477269,220247.229821107 150505.206787101, 220244.779251566 150505.61834893,220242.311439461 150505.909171266,220239.832329968 150506.078553494, 220237.347895479 150506.126087555,220234.864121215 150506.051658938,220232.386990804 150505.855446946, 220229.922471872 150505.537924272,220227.47650166 150505.099855856,220225.054972724 150504.542297043, 220222.663718741 150503.86659104,220220.308500449 150503.074365683, 220217.994991777 150502.167529512,220215.72876617 150501.148267175, 220213.515283163 150500.019034164,220211.35987523 150498.7825509, 220209.267734939 150497.441796181,220207.243902439 150496, 220205.293253319 150494.460635772,220203.420486864 150492.82741196,220201.630114732 150491.104263143, 220199.926450087 150489.295340538,220198.313597205 150487.405001997,220196.795441592 150485.437801511, 220195.375640616 150483.39847824,220194.057614703 150481.291945091,220192.844539092 150479.123276887,220191.739336189 150476.89769814, 220190.744668525 150474.620570464,220189.86293234 150472.297379659,220189.096251815 150469.933722495, 220188.446473951 150467.535293229,220187.915164118 150465.107869888,220187.50360229 150462.657300346, 220187.212779953 150460.189488241,220187.043397726 150457.710378749,220186.995863664 150455.22594426, 220187.070292282 150452.742169995,220187.266504273 150450.265039585,220187.584026947 150447.800520653, 220188.022095363 150445.35455044,220188.579654177 150442.933021505,220189.25536018 150440.541767521, 220190.047585536 150438.18654923,220190.954421707 150435.873040558,220191.973684044 150433.60681495, 220193.102917055 150431.393331943,220194.339400319 150429.237924011,220195.680155039 150427.14578372,220197.12195122 150425.12195122, 220198.661315447 150423.171302099,220200.29453926 150421.298535644,220202.017688077 150419.508163512,220203.826610682 150417.804498867, 220205.716949223 150416.191645986,220207.684149708 150414.673490372,220209.72347298 150413.253689397,220211.830006129 150411.935663483, 220213.998674333 150410.722587873,220216.22425308 150409.61738497,220218.501380756 150408.622717305,220220.824571561 150407.740981121, 220223.188228725 150406.974300596,220225.586657991 150406.324522731,220227 150406)
This example uses 3D input.
SELECT ST_CurveToLine('CIRCULARSTRING(220268 150415 1,220227 150505 2,220227 150406 3)');LINESTRING(220268 150415 1,220269.95064912 150416.539364228 1.0181172856673, 220271.823415575 150418.17258804 1.03623457133459,220273.613787707 150419.895736857 1.05435185700189,....AD INFINITUM .... 220225.586657991 150406.324522731 1.32611114201132,220227 150406 3)
Use only 2 segments to approximate quarter circle.
SELECT ST_CurveToLine('CIRCULARSTRING(220268 150415,220227 150505,220227 150406)', 2);LINESTRING(220268 150415,220287.740300149 150448.342699654,220278.12195122 150485.87804878, 220244.779251566 150505.61834893,220207.243902439 150496,220187.50360229 150462.657300346, 220197.12195122 150425.12195122,220227 150406)
Ensure the approximated line is no more than 20 units away from the original curve, and make the result direction-neutral.
SELECT ST_CurveToLine(
'CIRCULARSTRING(0 0,100 -100,200 0)'::geometry,
20,
1,
1
);LINESTRING(0 0,49.99999999999996 -86.60254037844383,149.99999999999994 -86.6025403784439,200 0)
ST_Scroll — Ändra startpunkt för en sluten LineString.
geometry ST_Scroll(geometry linestring, geometry point);
Ändrar start-/slutpunkten för en sluten LineString till den angivna toppunkten.
Tillgänglighet: 3.2.0
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder M-koordinater.
Make a closed line start at its 3rd vertex.
SELECT ST_Scroll('SRID=4326;LINESTRING(0 0 0 1,10 0 2 0,5 5 4 2,0 0 0 1)', 'POINT(5 5 4 2)');SRID=4326;LINESTRING(5 5 4 2,0 0 0 1,10 0 2 0,5 5 4 2)
ST_FlipCoordinates — Returnerar en version av en geometri med X- och Y-axlarna vända.
geometry ST_FlipCoordinates(geometry geom);
Returnerar en version av den angivna geometrin med X- och Y-axlarna vända. Användbar för att fixa geometrier som innehåller koordinater uttryckta som latitud/longitud (Y,X).
Tillgänglighet: 2.0.0
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder M-koordinater.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
SELECT ST_FlipCoordinates(GeomFromEWKT('POINT(1 2)'));POINT(2 1)
ST_Force2D — Tvinga geometrierna till ett "2-dimensionellt läge".
geometry ST_Force2D(geometry geomA);
Tvingar geometrierna till ett "2-dimensionellt läge" så att alla utdatarepresentationer endast har X- och Y-koordinaterna. Detta är användbart för att tvinga fram OGC-kompatibla utdata (eftersom OGC endast specificerar 2D-geometrier).
Förbättrad: 2.0.0 stöd för polyhedrala ytor infördes.
Ändrad: 2.1.0. Fram till 2.0.x kallades detta för ST_Force_2D.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder 3d och kommer inte att tappa z-index.
SELECT ST_Force2D('CIRCULARSTRING(1 1 2,2 3 2,4 5 2,6 7 2,5 6 2)');CIRCULARSTRING(1 1,2 3,4 5,6 7,5 6)
SELECT ST_Force2D('POLYGON((0 0 2,0 5 2,5 0 2,0 0 2),(1 1 2,3 1 2,1 3 2,1 1 2))');POLYGON((0 0,0 5,5 0,0 0),(1 1,3 1,1 3,1 1))
ST_Force3D — Tvingar geometrierna till XYZ-läge. Detta är ett alias för ST_Force3DZ.
geometry ST_Force3D(geometry geomA, float Zvalue = 0.0);
Forcerar geometrierna till XYZ-läge. Detta är ett alias för ST_Force3DZ. Om en geometri inte har någon Z-komponent läggs en Z-koordinat med Z-värde till.
Förbättrad: 2.0.0 stöd för polyhedrala ytor infördes.
Ändrad: 2.1.0. Fram till 2.0.x kallades detta ST_Force_3D.
Ändrad: 3.1.0. Lagt till stöd för att ange ett Z-värde som inte är noll.
Denna funktion stöder polyedriska ytor.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Nothing happens to an already 3D geometry.
SELECT ST_Force3D('CIRCULARSTRING(1 1 2,2 3 2,4 5 2,6 7 2,5 6 2)');CIRCULARSTRING(1 1 2,2 3 2,4 5 2,6 7 2,5 6 2)
SELECT ST_Force3D('POLYGON((0 0,0 5,5 0,0 0),(1 1,3 1,1 3,1 1))');POLYGON((0 0 0,0 5 0,5 0 0,0 0 0),(1 1 0,3 1 0,1 3 0,1 1 0))
ST_Force3DZ — Tvinga geometrierna till XYZ-läge.
geometry ST_Force3DZ(geometry geomA, float Zvalue = 0.0);
Tvingar geometrierna till XYZ-läge. Om en geometri inte har någon Z-komponent läggs en Z-koordinat med Z-värde till.
Förbättrad: 2.0.0 stöd för polyhedrala ytor infördes.
Ändrad: 2.1.0. Fram till 2.0.x kallades detta för ST_Force_3DZ.
Ändrad: 3.1.0. Lagt till stöd för att ange ett Z-värde som inte är noll.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
Nothing happens to an already 3D geometry.
SELECT ST_Force3DZ('CIRCULARSTRING(1 1 2,2 3 2,4 5 2,6 7 2,5 6 2)');CIRCULARSTRING(1 1 2,2 3 2,4 5 2,6 7 2,5 6 2)
SELECT ST_Force3DZ('POLYGON((0 0,0 5,5 0,0 0),(1 1,3 1,1 3,1 1))');POLYGON((0 0 0,0 5 0,5 0 0,0 0 0),(1 1 0,3 1 0,1 3 0,1 1 0))
ST_Force3DM — Tvinga geometrierna till XYM-läge.
geometry ST_Force3DM(geometry geomA, float Mvalue = 0.0);
Forcerar geometrierna till XYM-läge. Om en geometri inte har någon M-komponent läggs en M-koordinat med M-värde till. Om den har en Z-komponent tas Z bort
Ändrad: 2.1.0. Fram till 2.0.x kallades detta ST_Force_3DM.
Ändrad: 3.1.0. Stöd för att ange ett M-värde som inte är noll har lagts till.
Denna metod stöder cirkulära strängar och kurvor.
Nothing happens to an already 3D geometry.
SELECT ST_Force3DM('CIRCULARSTRING(1 1 2,2 3 2,4 5 2,6 7 2,5 6 2)');CIRCULARSTRINGM(1 1 0,2 3 0,4 5 0,6 7 0,5 6 0)
SELECT ST_Force3DM('POLYGON((0 0 1,0 5 1,5 0 1,0 0 1),(1 1 1,3 1 1,1 3 1,1 1 1))');POLYGONM((0 0 0,0 5 0,5 0 0,0 0 0),(1 1 0,3 1 0,1 3 0,1 1 0))
ST_AsEWKT, ST_Force2D, ST_Force3DM, ST_Force3D, ST_GeomFromEWKT
ST_Force4D — Tvinga geometrierna till XYZM-läge.
geometry ST_Force4D(geometry geomA, float Zvalue = 0.0, float Mvalue = 0.0);
Forcerar geometrierna till XYZM-läge. Z-värde och M-värde läggs till för saknade Z- respektive M-dimensioner.
Ändrad: 2.1.0. Fram till 2.0.x kallades detta ST_Force_4D.
Ändrad: 3.1.0. Stöd för att ange Z- och M-värden som inte är noll har lagts till.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
Nothing happens to an already 3D geometry.
SELECT ST_Force4D('CIRCULARSTRING(1 1 2,2 3 2,4 5 2,6 7 2,5 6 2)');CIRCULARSTRING(1 1 2 0,2 3 2 0,4 5 2 0,6 7 2 0,5 6 2 0)
SELECT ST_Force4D('MULTILINESTRINGM((0 0 1,0 5 2,5 0 3,0 0 4),(1 1 1,3 1 1,1 3 1,1 1 1))');MULTILINESTRING((0 0 0 1,0 5 0 2,5 0 0 3,0 0 0 4),(1 1 0 1,3 1 0 1,1 3 0 1,1 1 0 1))
ST_ForceCollection — Konvertera geometrin till en GEOMETRYCOLLECTION.
geometry ST_ForceCollection(geometry geomA);
Konverterar geometrin till en GEOMETRYCOLLECTION. Detta är användbart för att förenkla WKB-representationen.
Förbättrad: 2.0.0 stöd för polyhedrala ytor infördes.
Tillgänglighet: 1.2.2, före 1.3.4 kraschar den här funktionen med Curves. Detta är åtgärdat i 1.3.4+
Ändrad: 2.1.0. Fram till 2.0.x hette detta ST_Force_Collection.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
SELECT ST_ForceCollection('POLYGON((0 0 1,0 5 1,5 0 1,0 0 1),(1 1 1,3 1 1,1 3 1,1 1 1))');GEOMETRYCOLLECTION(POLYGON((0 0 1,0 5 1,5 0 1,0 0 1),(1 1 1,3 1 1,1 3 1,1 1 1)))
SELECT ST_ForceCollection('CIRCULARSTRING(220227 150406,2220227 150407,220227 150406)');GEOMETRYCOLLECTION(CIRCULARSTRING(220227 150406,2220227 150407,220227 150406))
This example uses a PolyhedralSurface.
SELECT ST_ForceCollection('POLYHEDRALSURFACE(((0 0 0,0 0 1,0 1 1,0 1 0,0 0 0)),
((0 0 0,0 1 0,1 1 0,1 0 0,0 0 0)),
((0 0 0,1 0 0,1 0 1,0 0 1,0 0 0)),
((1 1 0,1 1 1,1 0 1,1 0 0,1 1 0)),
((0 1 0,0 1 1,1 1 1,1 1 0,0 1 0)),
((0 0 1,1 0 1,1 1 1,0 1 1,0 0 1)))');GEOMETRYCOLLECTION(
POLYGON((0 0 0,0 0 1,0 1 1,0 1 0,0 0 0)),
POLYGON((0 0 0,0 1 0,1 1 0,1 0 0,0 0 0)),
POLYGON((0 0 0,1 0 0,1 0 1,0 0 1,0 0 0)),
POLYGON((1 1 0,1 1 1,1 0 1,1 0 0,1 1 0)),
POLYGON((0 1 0,0 1 1,1 1 1,1 1 0,0 1 0)),
POLYGON((0 0 1,1 0 1,1 1 1,0 1 1,0 0 1))
)
ST_AsEWKT, ST_Force2D, ST_Force3DM, ST_Force3D, ST_GeomFromEWKT
ST_ForceCurve — Upcasta en geometri till dess kurvade typ, om tillämpligt.
geometry ST_ForceCurve(geometry g);
Omvandlar en geometri till dess krökta representation, om tillämpligt: linjer blir sammansatta kurvor, multilinjer blir multikurvor polygoner blir kurvpolygoner multipolygoner blir multisurfaces. Om den inmatade geometrin redan är en krökt representation returneras samma som inmatningen.
Tillgänglighet: 2.2.0
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
SELECT ST_ForceCurve('POLYGON((0 0 2,5 0 2,0 5 2,0 0 2),(1 1 2,1 3 2,3 1 2,1 1 2))'::geometry
);CURVEPOLYGON Z ((0 0 2,5 0 2,0 5 2,0 0 2),(1 1 2,1 3 2,3 1 2,1 1 2))
ST_ForcePolygonCCW — Orienterar alla yttre ringar moturs och alla inre ringar medurs.
geometry ST_ForcePolygonCCW(geometry geom);
Tvingar (multi)polygoner att använda en motsols orientering för sin yttre ring och en medsols orientering för sina inre ringar. Icke-polygonala geometrier returneras oförändrade.
Tillgänglighet: 2.4.0
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder M-koordinater.
Force a polygon and its hole to use counter-clockwise exterior rings and clockwise interior rings.
WITH data AS (
SELECT 'POLYGON((0 0,0 4,4 4,4 0,0 0),
(1 1,3 1,3 3,1 3,1 1))'::geometry AS geom
)
SELECT geom AS input_polygon,
ST_ForcePolygonCCW(geom) AS ccw_polygon
FROM data;POLYGON((0 0,0 4,4 4,4 0,0 0),(1 1,3 1,3 3,1 3,1 1)) | POLYGON((0 0,4 0,4 4,0 4,0 0),(1 1,1 3,3 3,3 1,1 1))
ST_ForcePolygonCW — Orienterar alla yttre ringar medurs och alla inre ringar moturs.
geometry ST_ForcePolygonCW(geometry geom);
Tvingar (Multi)Polygoner att använda en medurs orientering för sin yttre ring och en moturs orientering för sina inre ringar. Icke-polygonala geometrier returneras oförändrade.
Tillgänglighet: 2.4.0
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder M-koordinater.
Force a polygon and its hole to use clockwise exterior rings and counter-clockwise interior rings.
WITH data AS (
SELECT 'POLYGON((0 0,4 0,4 4,0 4,0 0),
(1 1,1 3,3 3,3 1,1 1))'::geometry AS geom
)
SELECT geom AS input_polygon,
ST_ForcePolygonCW(geom) AS cw_polygon
FROM data;POLYGON((0 0,4 0,4 4,0 4,0 0),(1 1,1 3,3 3,3 1,1 1)) | POLYGON((0 0,0 4,4 4,4 0,0 0),(1 1,3 1,3 3,1 3,1 1))
ST_ForceSFS — Force geometries to use SFS 1.1 or 1.2 geometry types.
geometry ST_ForceSFS(geometry geomA);
geometry ST_ForceSFS(geometry geomA, text version);
Forces a geometry to use the geometry types defined by the requested version of the OGC Simple Features Specification. The default is SFS 1.1. Curved geometries are converted to linear representations, TRIANGLE is converted to POLYGON, and TIN and POLYHEDRALSURFACE are converted to GEOMETRYCOLLECTION values containing POLYGON elements.
If version begins with 1.2, curved geometries are still converted to linear representations, but TRIANGLE, TIN, and POLYHEDRALSURFACE are preserved. Other version values use the default SFS 1.1 behavior. Geometry collections are processed recursively, and the SRID and Z/M coordinates are preserved.
Tillgänglighet: 2.1.0
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Compare the geometry types produced for SFS 1.1 (the default) and SFS 1.2. Read each row from the input type in the direction of the result columns.
WITH inputs(geom) AS (VALUES
('CIRCULARSTRING(0 0, 1 1, 2 0)'::geometry),
('TRIANGLE((0 0, 0 2, 2 0, 0 0))'::geometry),
('TIN(((0 0, 0 2, 2 0, 0 0)))'::geometry),
('POLYHEDRALSURFACE(((0 0, 0 2, 2 0, 0 0)))'::geometry)
)
SELECT ST_GeometryType(geom) || ' →' AS input,
ST_GeometryType(ST_ForceSFS(geom)) AS "SFS 1.1 (default)",
ST_GeometryType(ST_ForceSFS(geom, '1.2')) AS "SFS 1.2"
FROM inputs;input | SFS 1.1 (default) | SFS 1.2 ------------------------+-----------------------+---------------------- ST_CircularString → | ST_LineString | ST_LineString ST_Triangle → | ST_Polygon | ST_Triangle ST_Tin → | ST_GeometryCollection | ST_Tin ST_PolyhedralSurface → | ST_GeometryCollection | ST_PolyhedralSurface (4 rows)
ST_ForceRHR — Tvinga orienteringen av hörnen i en polygon att följa högerhands-regeln.
geometry ST_ForceRHR(geometry g);
Tvingar orienteringen av hörnen i en polygon att följa en högerhandsregel, där det område som avgränsas av polygonen ligger till höger om gränsen. I synnerhet är den yttre ringen orienterad i medurs riktning och de inre ringarna i moturs riktning. Denna funktion är en synonym för ST_ForcePolygonCW
![]() | |
Ovanstående definition av högerhandsregeln står i konflikt med definitioner som används i andra sammanhang. För att undvika förvirring rekommenderas att man använder ST_ForcePolygonCW. |
Förbättrad: 2.0.0 stöd för polyhedrala ytor infördes.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
SELECT ST_ForceRHR('POLYGON((0 0 2,5 0 2,0 5 2,0 0 2),(1 1 2,1 3 2,3 1 2,1 1 2))'
);POLYGON((0 0 2,0 5 2,5 0 2,0 0 2),(1 1 2,3 1 2,1 3 2,1 1 2))
ST_LineExtend — Returnerar en linje som sträcker sig framåt och bakåt med angivna avstånd.
geometry ST_LineExtend(geometry line, float distance_forward, float distance_backward=0.0);
Returnerar en linje som förlängts framåt och bakåt genom att lägga till nya start- (och slut-) punkter på det eller de angivna avstånden. Ett avstånd på noll innebär inte att en punkt läggs till. Endast icke-negativa avstånd är tillåtna. Riktningen för den/de tillagda punkten/punkterna bestäms av de två första (och sista) distinkta punkterna på linjen. Duplicerade punkter ignoreras.
Tillgänglighet: 3.4.0
SELECT ST_LineExtend('LINESTRING(0 0,0 10)'::geometry, 5, 6);LINESTRING(0 -6,0 0,0 10,0 15)
ST_LineToCurve — Konverterar en linjär geometri till en krökt geometri.
geometry ST_LineToCurve(geometry geomANoncircular);
Konverterar vanlig LINESTRING/POLYGON till CIRKULÄRA STRINGAR och krökta polygoner. Observera att mycket färre punkter behövs för att beskriva den krökta motsvarigheten.
![]() | |
Om indata LINESTRING/POLYGON inte är tillräckligt krökt för att tydligt representera en kurva, kommer funktionen att returnera samma indatageometri. |
Tillgänglighet: 1.3.0
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
This example converts a linear Polygon approximating a circle to a CurvePolygon.
WITH data AS (
SELECT ST_Buffer('POINT(1 3)'::geometry, 3) AS geom
)
SELECT geom AS "input_Linear polygon",
ST_LineToCurve(geom) AS "Curved polygon"
FROM data;This example converts a 3D linear ring to a CircularString while preserving Z.
WITH data AS (
SELECT ST_Translate(
ST_Force3D(ST_Boundary(ST_Buffer(ST_Point(1, 3), 2, 2))),
0, 0, 3
) AS geom
)
SELECT geom AS "input_Linear ring at Z=3",
ST_LineToCurve(geom) AS "Circular string at Z=3"
FROM data;ST_Multi — Returnera geometrin som en MULTI*-geometri.
geometry ST_Multi(geometry geom);
Returnerar geometrin som en MULTI* geometrisamling. Om geometrin redan är en samling returneras den oförändrad.
A Polygon is converted to a single-element MultiPolygon. The coordinates are unchanged.
SELECT ST_Multi('POLYGON ((10 30,30 30,30 10,10 10,10 30))');MULTIPOLYGON(((10 30,30 30,30 10,10 10,10 30)))
ST_Normalize — Returnera geometrin i dess kanoniska form.
geometry ST_Normalize(geometry geom);
Returnerar geometrin i dess normaliserade/kanoniska form. Kan omordna hörn i polygonringar, ringar i en polygon, element i ett komplex med flera geometrier.
Oftast endast användbar för teständamål (jämförelse mellan förväntade och erhållna resultat).
Tillgänglighet: 2.3.0
SELECT ST_Normalize('GEOMETRYCOLLECTION(
POINT(2 3),
MULTILINESTRING((0 0,1 1),(2 2,3 3)),
POLYGON(
(0 10,0 0,10 0,10 10,0 10),
(4 2,2 2,2 4,4 4,4 2),
(6 8,8 8,8 6,6 6,6 8)
)
)');GEOMETRYCOLLECTION(POLYGON((0 0,0 10,10 10,10 0,0 0),(6 6,8 6,8 8,6 8,6 6),(2 2,4 2,4 4,2 4,2 2)), MULTILINESTRING((2 2,3 3),(0 0,1 1)), POINT(2 3))
ST_Project — Returnerar en punkt som projiceras från en startpunkt med ett avstånd och en bäring (azimut).
geometry ST_Project(geometry g1, float distance, float azimuth);
geometry ST_Project(geometry g1, geometry g2, float distance);
geography ST_Project(geography g1, float distance, float azimuth);
geography ST_Project(geography g1, geography g2, float distance);
Returnerar en punkt som projiceras från en punkt längs en geodetisk linje med hjälp av ett givet avstånd och azimut (bäring). Detta är känt som det direkta geodetiska problemet.
I tvåpunktsversionen används vägen från den första till den andra punkten för att implicit definiera azimut och avståndet används som tidigare.
Avståndet anges i meter. Negativa värden stöds.
Azimuten (även känd som kurs eller bäring) anges i radianer. Den mäts medurs från nordlig riktning.
Norr är azimut noll (0 grader)
Öst är azimut π/2 (90 grader)
Syd är azimut π (180 grader)
Väst är azimut 3π/2 (270 grader)
Negativa azimutvärden och värden som är större än 2π (360 grader) stöds.
Tillgänglighet: 2.0.0
Förbättrad: 2.4.0 Tillåt negativt avstånd och icke-normaliserad azimut.
Förbättrad: 3.4.0 Tillåt geometriargument och tvåpunktsform som utelämnar azimut.
SELECT ST_Project('POINT(0 0)'::geography, 100000, radians(45.0));POINT(0.635231029125537 0.639472334729198)
ST_QuantizeCoordinates — Sätter koordinaternas minst signifikanta bitar till noll
geometry ST_QuantizeCoordinates(geometry g, int prec_x, int prec_y = NULL, int prec_z = NULL, int prec_m = NULL);
ST_QuantizeCoordinates bestämmer antalet bitar(N) som krävs för att representera ett koordinatvärde med ett angivet antal siffror efter decimalpunkten, och sätter sedan alla utom de N mest signifikanta bitarna till noll. Det resulterande koordinatvärdet kommer fortfarande att avrundas till det ursprungliga värdet, men har förbättrad komprimerbarhet. Detta kan resultera i en betydande minskning av diskanvändningen, förutsatt att geometrikolumnen använder en komprimerbar lagringstyp. Funktionen tillåter specifikation av olika antal siffror efter decimaltecknet i varje dimension; ospecificerade dimensioner antas ha samma precision som x-dimensionen. Negativa siffror tolkas som siffror till vänster om decimaltecknet (t.ex. prec_x=-2 bevarar koordinatvärden till närmaste 100-tal).
De koordinater som produceras av ST_QuantizeCoordinates är oberoende av den geometri som innehåller dessa koordinater och av koordinaternas relativa position inom geometrin. Detta innebär att befintliga topologiska relationer mellan geometrier inte påverkas av användningen av denna funktion. Funktionen kan ge upphov till ogiltig geometri när den anropas med ett antal siffror som är lägre än geometrins egen precision.
Tillgänglighet: 2.5.0
PostGIS lagrar alla koordinatvärden som flyttalsintegraler med dubbel precision, som på ett tillförlitligt sätt kan representera 15 signifikanta siffror. PostGIS kan dock användas för att hantera data som i sig har färre än 15 signifikanta siffror. Ett exempel är TIGER-data, som tillhandahålls som geografiska koordinater med sex precisionssiffror efter decimaltecknet (vilket innebär att det endast krävs nio signifikanta siffror för longitud och åtta signifikanta siffror för latitud)
När 15 signifikanta siffror är tillgängliga finns det många möjliga representationer av ett tal med 9 signifikanta siffror. Ett flyttal med dubbel precision använder 52 explicita bitar för att representera koordinatens signifikand (mantissa). Endast 30 bitar behövs för att representera en mantissa med 9 signifikanta siffror, vilket ger 22 obetydliga bitar; vi kan ställa in deras värde till vad vi vill och ändå sluta med ett tal som avrundas till vårt inmatningsvärde. Till exempel kan värdet 100,123456 representeras av de flyttal som ligger närmast 100,123456000000, 100,123456000001 och 100,123456432199. Alla är lika giltiga, eftersom ST_AsText(geom, 6) kommer att returnera samma resultat med någon av dessa indata. Eftersom vi kan sätta dessa bitar till vilket värde som helst, sätter ST_QuantizeCoordinates de 22 obetydliga bitarna till noll. För en lång koordinatsekvens skapar detta ett mönster av block med på varandra följande nollor som komprimeras av PostgreSQL mer effektivt.
![]() | |
Endast geometrins storlek på disken påverkas potentiellt av |
SELECT ST_QuantizeCoordinates('POINT (100.123456 0)'::geometry, 4);POINT(100.12344360351562 0)
WITH test AS (SELECT 'POINT (123.456789123456 123.456789123456)'::geometry AS geom) SELECT digits, encode(ST_QuantizeCoordinates(geom, digits), 'hex'), ST_QuantizeCoordinates(geom, digits) FROM test, generate_series(15, -15, -1) AS digits;
digits | encode | st_astext
--------+--------------------------------------------+----------------------------------------------
15 | 01010000005f9a72083cdd5e405f9a72083cdd5e40 | POINT(123.456789123456 123.456789123456)
14 | 01010000005f9a72083cdd5e405f9a72083cdd5e40 | POINT(123.456789123456 123.456789123456)
13 | 01010000005e9a72083cdd5e405e9a72083cdd5e40 | POINT(123.45678912345599 123.45678912345599)
12 | 0101000000409a72083cdd5e40409a72083cdd5e40 | POINT(123.45678912345556 123.45678912345556)
11 | 0101000000009a72083cdd5e40009a72083cdd5e40 | POINT(123.45678912345466 123.45678912345466)
10 | 0101000000009872083cdd5e40009872083cdd5e40 | POINT(123.45678912344738 123.45678912344738)
9 | 0101000000008072083cdd5e40008072083cdd5e40 | POINT(123.45678912336007 123.45678912336007)
8 | 0101000000000070083cdd5e40000070083cdd5e40 | POINT(123.45678912103176 123.45678912103176)
7 | 0101000000000060083cdd5e40000060083cdd5e40 | POINT(123.4567891061306 123.4567891061306)
6 | 0101000000000000083cdd5e40000000083cdd5e40 | POINT(123.45678901672363 123.45678901672363)
5 | 0101000000000000003cdd5e40000000003cdd5e40 | POINT(123.456787109375 123.456787109375)
4 | 0101000000000000003cdd5e40000000003cdd5e40 | POINT(123.456787109375 123.456787109375)
3 | 01010000000000000038dd5e400000000038dd5e40 | POINT(123.45654296875 123.45654296875)
2 | 01010000000000000000dd5e400000000000dd5e40 | POINT(123.453125 123.453125)
1 | 01010000000000000000dc5e400000000000dc5e40 | POINT(123.4375 123.4375)
0 | 01010000000000000000c05e400000000000c05e40 | POINT(123 123)
-1 | 01010000000000000000005e400000000000005e40 | POINT(120 120)
-2 | 010100000000000000000058400000000000005840 | POINT(96 96)
-3 | 010100000000000000000058400000000000005840 | POINT(96 96)
-4 | 010100000000000000000058400000000000005840 | POINT(96 96)
-5 | 010100000000000000000058400000000000005840 | POINT(96 96)
-6 | 010100000000000000000058400000000000005840 | POINT(96 96)
-7 | 010100000000000000000058400000000000005840 | POINT(96 96)
-8 | 010100000000000000000058400000000000005840 | POINT(96 96)
-9 | 010100000000000000000058400000000000005840 | POINT(96 96)
-10 | 010100000000000000000058400000000000005840 | POINT(96 96)
-11 | 010100000000000000000058400000000000005840 | POINT(96 96)
-12 | 010100000000000000000058400000000000005840 | POINT(96 96)
-13 | 010100000000000000000058400000000000005840 | POINT(96 96)
-14 | 010100000000000000000058400000000000005840 | POINT(96 96)
-15 | 010100000000000000000058400000000000005840 | POINT(96 96)
(31 rows)ST_RemovePoint — Ta bort en punkt från en linestrings.
geometry ST_RemovePoint(geometry linestring, integer offset);
Tar bort en punkt från en LineString, givet dess index (0-baserat). Användbar för att förvandla en sluten linje (ring) till en öppen linestrings.
Förbättrad: 3.2.0
Tillgänglighet: 1.1.0
Denna funktion stöder 3d och kommer inte att tappa z-index.
Garanterar att inga linjer är slutna genom att ta bort slutpunkten för slutna linjer (ringar). Förutsätter att geom är av typen LINESTRING
UPDATE sometable
SET geom = ST_RemovePoint(geom, ST_NPoints(geom) - 1)
FROM sometable
WHERE ST_IsClosed(geom);
ST_RemoveRepeatedPoints — Returnerar en version av en geometri där dubbletter av punkter har tagits bort.
geometry ST_RemoveRepeatedPoints(geometry geom, float8 tolerance = 0.0);
Returnerar en version av den angivna geometrin där dubbla punkter har tagits bort. Funktionen bearbetar endast (Multi)LineStrings, (Multi)Polygons och MultiPoints men den kan anropas med alla typer av geometrier. Element i GeometryCollections bearbetas individuellt. Slutpunkterna för LineStrings bevaras.
Om en toleransparameter som inte är noll anges, anses vertikaler som ligger inom toleransavståndet från varandra vara duplikat. Avståndet beräknas i 2D (XY-planet).
Förbättrad: 3.2.0
Tillgänglighet: 2.2.0
Denna funktion stöder polyedriska ytor.
Denna funktion stöder 3d och kommer inte att tappa z-index.
SELECT ST_RemoveRepeatedPoints('MULTIPOINT ((1 1),(2 2),(3 3),(2 2))');MULTIPOINT((1 1),(2 2),(3 3))
SELECT ST_RemoveRepeatedPoints('LINESTRING (0 0,0 0,1 1,0 0,1 1,2 2)');LINESTRING(0 0,1 1,0 0,1 1,2 2)
Exempel: Samlingselement bearbetas individuellt.
SELECT ST_RemoveRepeatedPoints('GEOMETRYCOLLECTION (LINESTRING (1 1,2 2,2 2,3 3),POINT (4 4),POINT (4 4),POINT (5 5))');GEOMETRYCOLLECTION(LINESTRING(1 1,2 2,3 3), POINT(4 4), POINT(4 4), POINT(5 5))
Exempel: Upprepad punktborttagning med en avståndstolerans.
SELECT ST_RemoveRepeatedPoints('LINESTRING (0 0,0 0,1 1,5 5,1 1,2 2)', 2);LINESTRING(0 0,5 5,2 2)
ST_RemoveIrrelevantPointsForView — Tar bort punkter som är irrelevanta för rendering av en specifik rektangulär vy av en geometri.
geometry ST_RemoveIrrelevantPointsForView(geometry geom, box2d bounds, boolean cartesian_hint = false);
Returnerar en geometry utan punkter som är irrelevanta för rendering av geometrin inom en given rektangulär vy.
Denna funktion kan användas för att snabbt förbehandla geometrier som endast ska återges inom vissa gränser.
Endast geometrier av typen (MULTI)POLYGON och (MULTI)LINESTRING utvärderas. Övriga geometrier förblir oförändrade.
I motsats till ST_ClipByBox2D() är denna funktion
sorterar ut punkter utan att beräkna nya skärningspunkter, vilket undviker avrundningsfel och vanligtvis ökar prestandan,
returnerar en geometri med samma eller liknande punktnummer,
leder till samma renderingsresultat inom den angivna vyn, och
kan ge upphov till självskärningar som skulle göra den resulterande geometrin ogiltig (se exempel nedan).
Om cartesian_hint är satt till true tillämpar algoritmen ytterligare optimeringar som involverar cartesisk matematik för att ytterligare minska det resulterande punktantalet. Observera att om du använder det här alternativet kan det leda till renderingsartefakter om de resulterande koordinaterna projiceras till ett annat (icke-kartesiskt) koordinatsystem före rendering.
![]() | |
För polygoner säkerställer denna funktion för närvarande inte att resultatet är giltigt. Denna situation kan kontrolleras med ST_IsValid och repareras med ST_MakeValid. |
Tillgänglighet: 3.5.0
The input polygon has 55 points. The result retains 15 points, while rendering the same shape inside the view envelope.
WITH data(geom, view) AS (VALUES (
'POLYGON((3.2 14.2,6.8 14.2,7.6 11.9,7.2 9.8,7.8 7.2,10.3 7.2,11.5 7.5,13.8 7.2,14.6 5.9,14.2 4.8,14.8 3.2,14.6 0.9,13.2 -1.2,12.8 -3.8,12 -4.1,11 -4,9.8 -4.2,8.8 -4.8,8.3 -2.5,6.5 0.2,5.8 2.2,5.3 0.2,3.5 -1.5,2.8 -3.8,1.6 -4.5,-0.3 -5.2,-2.2 -5.8,-0.9 -4.8,-1.5 -4.4,-1.8 -2.8,-1.2 -1.8,0.5 -1.8,1.8 -1.8,2.3 -0.1,1.5 1.8,1.8 3.2,0 3.5,-3.2 4.2,-5.2 4.2,-4.4 4.9,-4.9 5.5,-4.3 5.9,-3.8 6.4,-3 6.9,-3.2 7.8,-2.2 8.2,-1.7 8.9,-2.7 9.4,-2.2 9.9,-1.4 10.9,-1.8 11.8,-1.2 12.2,-2.3 12.8,-2.9 13.2,0.6 13.5,3.2 14.2))'::geometry,
ST_MakeEnvelope(0.1, 0, 10, 10)
))
SELECT geom AS input_geom,
view AS input_view,
ST_RemoveIrrelevantPointsForView(geom, view, true) AS result,
view AS view
FROM data;Only linework affecting the view is retained; existing vertices are reused.
WITH data(geom, view) AS (VALUES (
'MULTILINESTRING((0 0,10 0,20 0,30 0),(0 15,5 15,10 15,15 15,20 15,25 15,30 15,40 15),(13 13,15 15,17 17))'::geometry,
ST_MakeEnvelope(12, 12, 18, 18)
))
SELECT geom AS input_geom,
view AS input_view,
ST_RemoveIrrelevantPointsForView(geom, view, true) AS result,
view AS view
FROM data;A line with no segment relevant to the view becomes empty.
SELECT ST_RemoveIrrelevantPointsForView('LINESTRING(0 0,10 0,20 0,30 0)',
ST_MakeEnvelope(12, 12, 18, 18), true);LINESTRING TOM
Removing vertices without computing intersections can introduce self-intersections in the result.
WITH data(geom, view) AS (VALUES (
'POLYGON((0 10,0 0,10 -10,30 0,25 20,10 -5,0 10))'::geometry,
ST_MakeEnvelope(-5, 1, 20, 12)
))
SELECT geom AS input_geom,
view AS input_view,
ST_RemoveIrrelevantPointsForView(geom, view, true) AS result,
view AS view
FROM data;With the default cartesian_hint, the function removes only points known to be irrelevant to the view.
WITH data(geom, view) AS (VALUES (
'POLYGON((0 30,15 30,30 30,30 0,0 0,0 30))'::geometry,
ST_MakeEnvelope(12, 12, 18, 18)
))
SELECT geom AS input_geom,
view AS input_view,
ST_RemoveIrrelevantPointsForView(geom, view) AS result,
view AS view
FROM data;ST_RemoveSmallParts — Tar bort små delar (polygonringar eller linestrings) av en geometri.
geometry ST_RemoveSmallParts(geometry geom, double precision minSizeX, double precision minSizeY);
Returnerar en geometry utan små delar (yttre eller inre polygonringar eller linestrings).
Denna funktion kan användas som ett förbehandlingssteg för att skapa förenklade kartor, t.ex. för att ta bort små öar eller hål.
Den utvärderar endast geometrier av typen (MULTI)POLYGON och (MULTI)LINESTRING. Andra geometrier förblir oförändrade.
Om minSizeX är större än 0 sorteras delar ut om deras bredd är mindre än minSizeX.
Om minSizeY är större än 0 sorteras delar ut om deras höjd är mindre än minSizeY.
Både minSizeX och minSizeY mäts i geometrins koordinatsystemenheter.
För polygontyper görs utvärderingen separat för varje ring, vilket kan leda till något av följande resultat:
den ursprungliga geometrin,
en POLYGON med alla ringar som har färre toppar,
en POLYGON med ett reducerat antal inre ringar (som eventuellt har färre toppar),
en POLYGON EMPTY, eller
en MULTIPOLYGON med ett reducerat antal polygoner (som eventuellt har färre inre ringar eller hörn), eller
en MULTIPOLYGON EMPTY.
För linestringstyper görs utvärderingen för varje linestrings, vilket kan leda till något av följande resultat:
den ursprungliga geometrin,
en LINESTRING med ett reducerat antal toppar,
a LINESTRING EMPTY,
en MULTILINESTRING med ett reducerat antal linestringsar (som eventuellt har färre toppar), eller
en MULTILINESTRING EMPTY.
Tillgänglighet: 3.5.0
SELECT ST_RemoveSmallParts('MULTIPOLYGON(
((60 160,120 160,120 220,60 220,60 160),(70 170,70 210,110 210,110 170,70 170)),
((85 75,155 75,155 145,85 145,85 75)),
((50 110,70 110,70 130,50 130,50 110)))',
50, 50);MULTIPOLYGON(((60 160,120 160,120 220,60 220,60 160)),((85 75,155 75,155 145,85 145,85 75)))
SELECT ST_RemoveSmallParts('LINESTRING(10 10,20 20)',
50, 50);LINESTRING TOM
ST_Reverse — Returnera geometrin med omvänd ordning på topparna.
geometry ST_Reverse(geometry g1);
Kan användas på vilken geometri som helst och vänder på ordningen på hörnen.
Förbättrad: 2.4.0 stöd för kurvor infördes.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
WITH data(geom) AS (VALUES (
ST_MakeLine(ST_Point(1, 2), ST_Point(1, 10))
))
SELECT geom AS input_line,
ST_Reverse(geom) AS reversed_line
FROM data;input_line | reversed_line ----------------------+---------------------- LINESTRING(1 2,1 10) | LINESTRING(1 10,1 2) (1 row)
ST_Segmentize — Returnerar en modifierad geometri/geografi som inte har något segment som är längre än ett givet avstånd.
geometry ST_Segmentize(geometry geom, float max_segment_length);
geography ST_Segmentize(geography geog, float max_segment_length);
Returnerar en modifierad geometri/geografi som inte har något segment som är längre än max_segment_length. Längden beräknas i 2D. Segmenten delas alltid upp i lika långa undersegment.
För geometri är den maximala längden i enheterna i det spatiala referenssystemet.
För geografi är den maximala längden i meter. Avstånden beräknas på sfären. Tillagda hörnpunkter skapas längs de sfäriska storcirkelbågar som definieras av segmentets ändpunkter.
![]() | |
Detta förkortar endast långa segment. Den förlänger inte segment som är kortare än den maximala längden. |
![]() | |
För indata som innehåller långa segment kan en relativt kort |
Tillgänglighet: 1.2.2
Förbättrad: 3.0.0 Segmentize-geometri producerar nu lika långa undersegment
Förbättrad: 2.3.0 Segmentize-geografin producerar nu lika långa undersegment
Förbättrad: 2.1.0 stöd för geografi infördes.
Ändrad: 2.1.0 Som ett resultat av införandet av geografistöd orsakar användningen ST_Segmentize('LINESTRING(1 2, 3 4)', 0.5) ett tvetydigt funktionsfel. Indata måste vara korrekt typad som en geometri eller geografi. Använd ST_GeomFromText, ST_GeogFromText eller en cast till den nödvändiga typen (t.ex. ST_Segmentize('LINESTRING(1 2, 3 4)'::geometry, 0.5) )
Segmentisering av en linje. Långa segment delas upp jämnt, medan korta segment inte delas upp.
SELECT ST_Segmentize('MULTILINESTRING((0 0,0 1,0 9),(1 10,1 18))'::geometry,
5);MULTILINESTRING((0 0,0 1,0 5,0 9),(1 10,1 14,1 18))
Segmentisering av en polygon:
SELECT ST_Segmentize('POLYGON((0 0,0 8,30 0,0 0))'::geometry,
10);POLYGON((0 0,0 8,7.5 6,15 4,22.5 2,30 0,20 0,10 0,0 0))
Segmentisering av en geografisk linje med en maximal segmentlängd på 2000 kilometer. Hörnpunkter läggs till längs den storcirkelbåge som förbinder ändpunkterna.
SELECT ST_Segmentize(('LINESTRING (0 0,60 60)'::geography), 2000000);LINESTRING(0 0,4.252632294621186 8.43596525986862,8.69579947419404 16.824093489701564,13.550465473227048 25.107950473646188,19.1066053508691 33.21091076089908,25.779290201459894 41.01711439406505,34.188839517966954 48.337222885886,45.238153936612264 54.84733442373889,60 60)
ST_SetPoint — Ersätt punkten i en linestrings med en given punkt.
geometry ST_SetPoint(geometry linestring, integer zerobasedposition, geometry point);
Ersätter punkt N i linestrings med given punkt. Index är 0-baserat. Negativa index räknas baklänges, så att -1 är sista punkten. Detta är särskilt användbart i triggers när man försöker bibehålla relationen mellan lederna när en vertex flyttas.
Tillgänglighet: 1.1.0
Uppdaterad 2.3.0: negativ indexering
Denna funktion stöder 3d och kommer inte att tappa z-index.
Change first point in line string from -1 3 to -1 1.
SELECT ST_SetPoint('LINESTRING(-1 2,-1 3)', 0, 'POINT(-1 1)');LINESTRING(-1 1,-1 3)
Change last point in a line string (let's play with 3D linestring this time)
SELECT ST_SetPoint(foo.geom, ST_NumPoints(foo.geom) - 1, 'POINT(-1 1 3)') FROM (SELECT 'LINESTRING(-1 2 3,-1 3 4,5 6 7)'::geometry As geom) As foo;
LINESTRING(-1 2 3,-1 3 4,-1 1 3)
SELECT ST_SetPoint(g, -3, p)
FROM ST_GeomFromText('LINESTRING(0 0,1 1,2 2,3 3,4 4)') AS g
CROSS JOIN ST_PointN(g, 1) as p;LINESTRING(0 0,1 1,0 0,3 3,4 4)
ST_AddPoint, ST_NPoints, ST_NumPoints, ST_PointN, ST_RemovePoint
ST_ShiftLongitude — Flyttar longitudkoordinaterna för en geometri mellan -180..180 och 0..360.
geometry ST_ShiftLongitude(geometry geom);
Läser varje punkt/vertex i en geometri och flyttar dess longitudkoordinat från -180..0 till 180..360 och vice versa om den ligger mellan dessa intervall. Denna funktion är symmetrisk så resultatet är en 0..360-representation av en -180..180-data och en -180..180-representation av en 0..360-data.
![]() | |
Detta är endast användbart för data med koordinater i longitud/latitud, t.ex. SRID 4326 (WGS 84 geographic) |
![]() | |
Före 1.3.4 hindrade buggen detta från att fungera för MULTIPOINT. 1.3.4+ fungerar även med MULTIPOINT. |
Denna funktion stöder 3d och kommer inte att tappa z-index.
Förbättrad: 2.0.0 stöd för polyhedrala ytor och TIN infördes.
OBS: denna funktion döptes om från "ST_Shift_Longitude" i 2.2.0
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
This example performs a forward longitude shift on a single point.
SELECT ST_ShiftLongitude('SRID=4326;POINT(270 0)'::geometry)POINT(-90 0)
This example performs a reverse longitude shift on a single point.
SELECT ST_ShiftLongitude('SRID=4326;POINT(-90 0)'::geometry)POINT(270 0)
This example shows that LineStrings are shifted only where coordinates require it.
SELECT ST_ShiftLongitude('SRID=4326;LINESTRING(174 12,182 13)'::geometry)LINESTRING(174 12,-178 13)
ST_WrapX — Omsluta en geometri runt ett X-värde.
geometry ST_WrapX(geometry geom, float8 wrap, float8 move);
Denna funktion delar upp inmatningsgeometrierna och flyttar sedan varje resulterande komponent som faller till höger (för negativ "move") eller till vänster (för positiv "move") om den givna "wrap"-linjen i den riktning som anges av "move"-parametern, och sammanfogar slutligen bitarna igen.
![]() | |
Detta är användbart för att "omcentrera" Long-Lat Input så att intressanta funktioner inte skapas från den ena sidan till den andra. |
Tillgänglighet: 2.3.0 kräver GEOS
Denna funktion stöder 3d och kommer inte att tappa z-index.
Move all components whose bounding boxes fall completely to the left of x = 0 by +360.
SELECT ST_WrapX(geom, 0, 360);
Move all components whose bounding boxes fall completely to the left of x = -30 by +360.
SELECT ST_WrapX(geom, -30, 360);
ST_SnapToGrid — Fäst alla punkter i indatageometrin i ett regelbundet rutnät.
geometry ST_SnapToGrid(geometry geomA, float originX, float originY, float sizeX, float sizeY);
geometry ST_SnapToGrid(geometry geomA, float sizeX, float sizeY);
geometry ST_SnapToGrid(geometry geomA, float size);
geometry ST_SnapToGrid(geometry geomA, geometry pointOrigin, float sizeX, float sizeY, float sizeZ, float sizeM);
Variant 1,2,3: Fäst alla punkter i indatageometrin i det rutnät som definieras av dess ursprung och cellstorlek. Ta bort på varandra följande punkter som faller på samma cell, och returnera slutligen NULL om utdatapunkterna inte är tillräckliga för att definiera en geometri av den givna typen. Kollapsade geometrier i en samling tas bort från den. Användbart för att minska precisionen.
Variant 4: Introducerad 1.1.0 - Snappa alla punkter i indatageometrin till det rutnät som definieras av dess ursprung (det andra argumentet, måste vara en punkt) och cellstorlekar. Ange 0 som storlek för alla dimensioner som du inte vill fästa i ett rutnät.
![]() | |
Den återlämnade geometrin kan förlora sin enkelhet (se ST_IsSimple). |
![]() | |
Före release 1.1.0 returnerade denna funktion alltid en 2D-geometri. Från och med 1.1.0 kommer den returnerade geometrin att ha samma dimensionalitet som den inmatade geometrin med högre dimensionsvärden orörda. Använd versionen som tar ett andra geometriargument för att definiera alla rutnätsdimensioner. |
Tillgänglighet: 1.0.0RC1
Tillgänglighet: 1.1.0 - Stöd för Z och M
Denna funktion stöder 3d och kommer inte att tappa z-index.
Snap a geometry column to a precision grid of 10^-3.
UPDATE mytable SET geom = ST_SnapToGrid(geom, 0.001);
Display how the same grid size rounds a LineString.
SELECT ST_SnapToGrid('LINESTRING(1.1115678 2.123,4.111111 3.2374897,4.11112 3.23748667)'::geometry,
0.001);LINESTRING(1.112 2.123,4.111 3.237)
This example snaps a 4D geometry.
SELECT ST_SnapToGrid('LINESTRING(-1.1115678 2.123 2.3456 1.11111,
4.111111 3.2374897 3.1234 1.1111,-1.11111112 2.123 2.3456 1.1111112)'::geometry,
'POINT(1.12 2.22 3.2 4.4444)',
0.1, 0.1, 0.1, 0.01);LINESTRING(-1.08 2.12 2.3 1.1144,4.12 3.22 3.1 1.1144,-1.08 2.12 2.3 1.1144)
With a 4D geometry - the ST_SnapToGrid(geom,size) only touches x and y coords but keeps m and z the same.
SELECT ST_SnapToGrid('LINESTRING(-1.1115678 2.123 3 2.3456,
4.111111 3.2374897 3.1234 1.1111)'::geometry,
0.01);LINESTRING(-1.11 2.12 3 2.3456,4.11 3.24 3.1234 1.1111)
ST_Snap, ST_AsEWKT, ST_AsText, ST_GeomFromText, ST_GeomFromEWKT, ST_Simplify
ST_Snap — Fäst segment och vertikaler i indatageometrin till vertikaler i en referensgeometri.
geometry ST_Snap(geometry input, geometry reference, float tolerance);
Snappar en geometris hörn och segment till en annan geometris hörn. En tolerans för snäppavstånd används för att styra var snäppningen utförs. Resultatgeometrin är indatageometrin med de snäppta topparna. Om ingen snäppning sker returneras indatageometrin oförändrad.
Att snäppa en geometri till en annan kan förbättra robustheten för överlagringsoperationer genom att eliminera nästan sammanfallande kanter (som orsakar problem under nodning och intersektionsberäkning).
För mycket snäppning kan leda till att en ogiltig topologi skapas, så antalet och placeringen av de snäppta topparna bestäms med hjälp av heuristik för att avgöra när det är säkert att snäppa. Detta kan dock leda till att vissa potentiella snäppningar utelämnas.
![]() | |
Den återlämnade geometrin kan förlora sin enkelhet (se ST_IsSimple) och giltighet (se ST_IsValid). |
Utförs av GEOS-modulen.
Tillgänglighet: 2.0.0
A MultiPolygon snapped to a LineString at 1.01 times their distance.
SELECT ST_Snap(poly, line, ST_Distance(poly, line)*1.01) AS polysnapped
FROM (SELECT
ST_GeomFromText('MULTIPOLYGON(
((26 125,26 200,126 200,126 125,26 125 ),
( 51 150,101 150,76 175,51 150 )),
(( 151 100,151 200,176 175,151 100 )))') As poly,
ST_GeomFromText('LINESTRING (5 107,54 84,101 100)') As line
) As foo;MULTIPOLYGON(((26 125,26 200,126 200,126 125,101 100,26 125), (51 150,101 150,76 175,51 150)),((151 100,151 200,176 175,151 100)))
A MultiPolygon snapped to a LineString at 1.25 times their distance.
SELECT ST_Snap(poly, line, ST_Distance(poly, line)*1.25) AS polysnapped
FROM (SELECT
ST_GeomFromText('MULTIPOLYGON(
(( 26 125,26 200,126 200,126 125,26 125 ),
( 51 150,101 150,76 175,51 150 )),
(( 151 100,151 200,176 175,151 100 )))') As poly,
ST_GeomFromText('LINESTRING (5 107,54 84,101 100)') As line
) As foo;MULTIPOLYGON(((5 107,26 200,126 200,126 125,101 100,54 84,5 107), (51 150,101 150,76 175,51 150)),((151 100,151 200,176 175,151 100)))
The LineString snapped to the original MultiPolygon at 1.01 times their distance.
SELECT ST_Snap(line, poly, ST_Distance(poly, line)*1.01) AS linesnapped
FROM (SELECT
ST_GeomFromText('MULTIPOLYGON(
((26 125,26 200,126 200,126 125,26 125),
(51 150,101 150,76 175,51 150 )),
((151 100,151 200,176 175,151 100)))') As poly,
ST_GeomFromText('LINESTRING (5 107,54 84,101 100)') As line
) As foo;LINESTRING(5 107,26 125,54 84,101 100)
The LineString snapped to the original MultiPolygon at 1.25 times their distance.
SELECT ST_Snap(line, poly, ST_Distance(poly, line)*1.25) AS linesnapped
FROM (SELECT
ST_GeomFromText('MULTIPOLYGON(
(( 26 125,26 200,126 200,126 125,26 125 ),
(51 150,101 150,76 175,51 150 )),
((151 100,151 200,176 175,151 100 )))') As poly,
ST_GeomFromText('LINESTRING (5 107,54 84,101 100)') As line
) As foo;LINESTRING(26 125,54 84,101 100)
ST_SwapOrdinates — Returnerar en version av den givna geometrin med givna ordinatvärden ombytta.
geometry ST_SwapOrdinates(geometry geom, cstring ords);
Returnerar en version av den givna geometrin med givna ordinater ombytta.
Parametern ords är en sträng med 2 tecken som namnger de ordinater som ska bytas ut. Giltiga namn är: x,y,z och m.
Tillgänglighet: 2.2.0
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder M-koordinater.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
This example scales the M value by 2.
SELECT ST_SwapOrdinates(ST_Scale(ST_SwapOrdinates(g, 'xm'),
2, 1
),
'xm') FROM ( SELECT 'POINT ZM (0 0 0 2)'::geometry g ) foo;POINT ZM (0 0 0 4)
Dessa funktioner testar om geometrierna är giltiga enligt OGC SFS-standarden. De ger också information om ogiltighetens art och plats. Det finns också en funktion för att skapa en giltig geometri från en ogiltig.
valid_detail-rad som anger om en geometri är giltig eller om den inte är det, en orsak och en plats.ST_IsValid — Testar om en geometri är välformad i 2D.
boolean ST_IsValid(geometry g);
boolean ST_IsValid(geometry g, integer flags);
Testar om ett ST_Geometry-värde är välformat och giltigt i 2D enligt OGC:s regler. För geometrier med 3 och 4 dimensioner testas giltigheten fortfarande bara i 2 dimensioner. För geometrier som är ogiltiga skickas en PostgreSQL NOTICE ut med information om varför den inte är giltig.
För versionen med parametern flags dokumenteras de värden som stöds i ST_IsValidDetail. Den här versionen skriver inte ut något meddelande som förklarar ogiltigheten.
För mer information om definitionen av geometrisk validitet, se Avsnitt 4.4, ”Validering av geometri”
![]() | |
SQL-MM definierar att resultatet av ST_IsValid(NULL) ska vara 0, medan PostGIS returnerar NULL. |
Utförs av GEOS-modulen.
Den version som accepterar flaggor är tillgänglig från och med 2.0.0.
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.9
![]() | |
Varken OGC-SFS eller SQL-MM-specifikationerna innehåller ett flaggargument för ST_IsValid. Flaggan är en PostGIS-utökning. |
SELECT ST_IsValid('LINESTRING(0 0,1 1)') As good_line,
ST_IsValid('POLYGON((0 0,1 1,1 2,1 1,0 0))') As bad_poly;NOTICE: Self-intersection at or near point 0 0 good_line | bad_poly -----------+---------- t | f
Find tables with invalid geometries in registered geometry columns.
CREATE TEMP TABLE invalid_geometry_columns (
table_name text,
column_name text,
invalid_count bigint
);
DO $$
DECLARE
rec record;
invalid_count bigint;
BEGIN
FOR rec IN
SELECT f_table_schema, f_table_name, f_geometry_column
FROM geometry_columns
ORDER BY f_table_schema, f_table_name, f_geometry_column
LOOP
EXECUTE format(
'SELECT count(*) FROM %I.%I WHERE NOT ST_IsValid(%I, 0)',
rec.f_table_schema,
rec.f_table_name,
rec.f_geometry_column
) INTO invalid_count;
IF invalid_count
> 0 THEN
INSERT INTO invalid_geometry_columns
VALUES (
format('%I.%I', rec.f_table_schema, rec.f_table_name),
rec.f_geometry_column,
invalid_count
);
END IF;
END LOOP;
END;
$$;
SELECT * FROM invalid_geometry_columns;
ST_IsValidDetail — Returnerar en valid_detail-rad som anger om en geometri är giltig eller om den inte är det, en orsak och en plats.
valid_detail ST_IsValidDetail(geometry geom, integer flags);
Returnerar en valid_detail-rad som innehåller en boolean (valid) som anger om en geometri är giltig, en varchar (reason) som anger varför den är ogiltig och en geometri(location) som pekar ut var den är ogiltig.
Användbar för att förbättra kombinationen av ST_IsValid och ST_IsValidReason för att generera en detaljerad rapport om ogiltiga geometrier.
Den valfria parametern flags är ett bitfält. Den kan ha följande värden:
0: Använd vanlig OGC SFS-validitetssemantik.
1: Betrakta vissa typer av självberörande ringar (inverterade skal och exverterade hål) som giltiga. Detta är också känt som "ESRI-flaggan", eftersom det är den giltighetsmodell som används av dessa verktyg. Observera att detta är ogiltigt enligt OGC-modellen.
Utförs av GEOS-modulen.
Tillgänglighet: 2.0.0
This example returns the first three rejects from a successful quintuplet experiment.
SELECT gid, reason(ST_IsValidDetail(geom)), location(ST_IsValidDetail(geom)) as location
FROM
(SELECT ST_MakePolygon(ST_ExteriorRing(e.buff), array_agg(f.line)) As geom, gid
FROM (SELECT ST_Buffer(ST_Point(x1*10,y1), z1) As buff, x1*10 + y1*100 + z1*1000 As gid
FROM generate_series(-4,6) x1
CROSS JOIN generate_series(2,5) y1
CROSS JOIN generate_series(1,8) z1
WHERE x1
> y1*0.5 AND z1 < x1*y1) As e
INNER JOIN (SELECT ST_Translate(ST_ExteriorRing(ST_Buffer(ST_Point(x1*10,y1), z1)),y1*1, z1*2) As line
FROM generate_series(-3,6) x1
CROSS JOIN generate_series(2,5) y1
CROSS JOIN generate_series(1,10) z1
WHERE x1
> y1*0.75 AND z1 < x1*y1) As f
ON (ST_Area(e.buff)
> 78 AND ST_Contains(e.buff, f.line))
GROUP BY gid, e.buff) As quintuplet_experiment
WHERE ST_IsValid(geom) = false
ORDER BY gid
LIMIT 3;gid | reason | location ------+-------------------+------------- 5330 | Self-intersection | POINT(32 5) 5340 | Self-intersection | POINT(42 5) 5350 | Self-intersection | POINT(52 5)
This example reports a valid LineString.
SELECT * FROM ST_IsValidDetail('LINESTRING(220227 150406,2220227 150407,222020 150410)');valid | reason | location -------+--------+---------- t | |
ST_IsValidReason — Returnerar text som anger om en geometri är giltig, eller en orsak till ogiltigheten.
text ST_IsValidReason(geometry geomA);
text ST_IsValidReason(geometry geomA, integer flags);
Returnerar text som anger om en geometri är giltig, eller om den är ogiltig en orsak till detta.
Används i kombination med ST_IsValid för att generera en detaljerad rapport om ogiltiga geometrier och orsaker.
Tillåtna flaggor finns dokumenterade i ST_IsValidDetail.
Utförs av GEOS-modulen.
Tillgänglighet: 1.4
Tillgänglighet: 2.0-versionen tar flaggor.
This example uses an invalid bow-tie polygon.
SELECT ST_IsValidReason(
'POLYGON ((100 200,100 100,200 200,
200 100,100 200))'::geometry) as validity_info;Self-intersection[150 150]
This example returns the first three rejects from a successful quintuplet experiment.
SELECT gid, ST_IsValidReason(geom) as validity_info
FROM
(SELECT ST_MakePolygon(ST_ExteriorRing(e.buff), array_agg(f.line)) As geom, gid
FROM (SELECT ST_Buffer(ST_Point(x1*10,y1), z1) As buff, x1*10 + y1*100 + z1*1000 As gid
FROM generate_series(-4,6) x1
CROSS JOIN generate_series(2,5) y1
CROSS JOIN generate_series(1,8) z1
WHERE x1
> y1*0.5 AND z1 < x1*y1) As e
INNER JOIN (SELECT ST_Translate(ST_ExteriorRing(ST_Buffer(ST_Point(x1*10,y1), z1)),y1*1, z1*2) As line
FROM generate_series(-3,6) x1
CROSS JOIN generate_series(2,5) y1
CROSS JOIN generate_series(1,10) z1
WHERE x1
> y1*0.75 AND z1 < x1*y1) As f
ON (ST_Area(e.buff)
> 78 AND ST_Contains(e.buff, f.line))
GROUP BY gid, e.buff) As quintuplet_experiment
WHERE ST_IsValid(geom) = false
ORDER BY gid
LIMIT 3;gid | validity_info ------+-------------------------- 5330 | Self-intersection [32 5] 5340 | Self-intersection [42 5] 5350 | Self-intersection [52 5]
Simple example.
SELECT ST_IsValidReason('LINESTRING(220227 150406,2220227 150407,222020 150410)');st_isvalidreason ------------------ Valid Geometry
ST_MakeValid — Försöker göra en ogiltig geometri giltig utan att förlora toppar.
geometry ST_MakeValid(geometry input);
geometry ST_MakeValid(geometry input, text params);
Funktionen försöker skapa en giltig representation av en given ogiltig geometri utan att förlora någon av de ingående hörnen. Giltiga geometrier returneras oförändrade.
Ingångar som stöds är: POINTS, MULTIPOINTS, LINESTRINGS, MULTILINESTRINGS, POLYGONS, MULTIPOLYGONS och GEOMETRYCOLLECTIONS som innehåller alla blandningar av dem.
Vid fullständig eller partiell dimensionell kollaps kan utdatageometrin vara en samling geometrier med lägre till lika stor dimension, eller en geometri med lägre dimension.
Enstaka polygoner kan bli multigeometrier vid självskärningar.
Argumentet params kan användas för att ange en alternativsträng för att välja vilken metod som ska användas för att bygga giltig geometri. Alternativsträngen är i formatet "method=linework|structure keepcollapsed=true|false". Om inget "params"-argument anges kommer "linework"-algoritmen att användas som standard.
"Method"-nyckeln har två värden.
"linework" is the default algorithm, and builds valid geometries by first extracting all lines, noding that linework together, then building a value output from the linework. The requirement that no vertices are lost can generate complex collections as outputs.
"structure" is an algorithm that distinguishes between interior and exterior rings, building new geometry by unioning exterior rings, and then differencing all interior rings. The results tend to be more intuitive, where collapsed lines are discarded in the output.
The "keepcollapsed" key is only valid for the "structure" algorithm, and takes a value of "true" or "false".
Keep collapsed of "false" is the default, and means that geometry components that collapse to a lower dimensionality, for example a one-point linestring will be dropped.
Keep collapsed of "true" means geometry components that collapse to a lower dimensionality will be retained.
Utförs av GEOS-modulen.
Tillgänglighet: 2.0.0
Förbättrad: 2.0.1, hastighetsförbättringar
Förbättrad: 2.1.0, stöd för GEOMETRYCOLLECTION och MULTIPOINT har lagts till.
Förbättrad: 3.1.0, har lagt till borttagning av koordinater med NaN-värden.
Förbättrad: 3.2.0, algoritmalternativen "linework" och "structure" har lagts till, vilket kräver GEOS >= 3.10.0.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Make valid a MultiPolygon of two overlapping polygons using the linework and structure methods.
SELECT ST_MakeValid(before_geom) AS linework, ST_MakeValid(before_geom, 'method=structure') AS structure FROM (SELECT 'MULTIPOLYGON(((186 194,187 194,188 195,189 195,190 195, 191 195,192 195,193 194,194 194,194 193,195 192,195 191, 195 190,195 189,195 188,194 187,194 186,14 6,13 6,12 5,11 5, 10 5,9 5,8 5,7 6,6 6,6 7,5 8,5 9,5 10,5 11,5 12,6 13,6 14,186 194)), ((150 90,149 80,146 71,142 62,135 55,128 48,119 44,110 41,100 40, 90 41,81 44,72 48,65 55,58 62,54 71,51 80,50 90,51 100, 54 109,58 118,65 125,72 132,81 136,90 139,100 140,110 139, 119 136,128 132,135 125,142 118,146 109,149 100,150 90)))'::geometry AS before_geom) AS f;
MULTIPOLYGON(((11 5,10 5,9 5,8 5,7 6,6 6,6 7,5 8,5 9,5 10,5 11,5 12,6 13,6 14,56.769 64.769,58 62,64 56,14 6,13 6,12 5,11 5)),((54 71,51 80,50 90,51 100,54 109,58 118,65 125,72 132,81 136,90 139,100 140,110 139,119 136,125.231 133.231,56.769 64.769,54 71)),((186 194,187 194,188 195,189 195,190 195,191 195,192 195,193 194,194 194,194 193,195 192,195 191,195 190,195 189,195 188,194 187,194 186,134 126,128 132,125.231 133.231,186 194)),((135 125,142 118,146 109,149 100,150 90,149 80,146 71,142 62,135 55,128 48,119 44,110 41,100 40,90 41,81 44,72 48,65 55,64 56,134 126,135 125))) | MULTIPOLYGON(((149 80,146 71,142 62,135 55,128 48,119 44,110 41,100 40,90 41,81 44,72 48,65 55,64 56,14 6,13 6,12 5,11 5,10 5,9 5,8 5,7 6,6 6,6 7,5 8,5 9,5 10,5 11,5 12,6 13,6 14,56.769 64.769,54 71,51 80,50 90,51 100,54 109,58 118,65 125,72 132,81 136,90 139,100 140,110 139,119 136,125.231 133.231,186 194,187 194,188 195,189 195,190 195,191 195,192 195,193 194,194 194,194 193,195 192,195 191,195 190,195 189,195 188,194 187,194 186,134 126,135 125,142 118,146 109,149 100,150 90,149 80)))
Make valid a MultiPolygon of six overlapping polygons using the linework and structure methods.
SELECT ST_MakeValid(before_geom) AS linework,
ST_MakeValid(before_geom, 'method=structure') AS structure
FROM (SELECT 'MULTIPOLYGON(((91 50,79 22,51 10,23 22,11 50,23 78,51 90,79 78,91 50)),
((91 100,79 72,51 60,23 72,11 100,23 128,51 140,79 128,91 100)),
((91 150,79 122,51 110,23 122,11 150,23 178,51 190,79 178,91 150)),
((141 50,129 22,101 10,73 22,61 50,73 78,101 90,129 78,141 50)),
((141 100,129 72,101 60,73 72,61 100,73 128,101 140,129 128,141 100)),
((141 150,129 122,101 110,73 122,61 150,73 178,101 190,129 178,141 150)))'::geometry AS before_geom) AS c;MULTIPOLYGON(((51 110,68.5 117.5,61 100,68.5 82.5,51 90,23 78,21.714 75,11 100,21.714 125,23 122,51 110)),((51 190,76 179.286,73 178,61 150,68.5 132.5,51 140,23 128,21.714 125,11 150,23 178,51 190)),((141 150,130.286 125,129 128,101 140,83.5 132.5,91 150,79 178,76 179.286,101 190,129 178,141 150)),((129 78,101 90,83.5 82.5,91 100,83.5 117.5,101 110,129 122,130.286 125,141 100,130.286 75,129 78)),((101 10,76 20.714,79 22,91 50,83.5 67.5,101 60,129 72,130.286 75,141 50,129 22,101 10)),((11 50,21.714 75,23 72,51 60,68.5 67.5,61 50,73 22,76 20.714,51 10,23 22,11 50)),((83.5 82.5,80.286 75,79 78,76 79.286,83.5 82.5)),((83.5 67.5,76 70.714,79 72,80.286 75,83.5 67.5)),((68.5 67.5,71.714 75,73 72,76 70.714,68.5 67.5)),((68.5 82.5,76 79.286,73 78,71.714 75,68.5 82.5)),((83.5 132.5,80.286 125,79 128,76 129.286,83.5 132.5)),((83.5 117.5,76 120.714,79 122,80.286 125,83.5 117.5)),((68.5 117.5,71.714 125,73 122,76 120.714,68.5 117.5)),((68.5 132.5,76 129.286,73 128,71.714 125,68.5 132.5))) | MULTIPOLYGON(((23 22,11 50,21.714 75,11 100,21.714 125,11 150,23 178,51 190,76 179.286,101 190,129 178,141 150,130.286 125,141 100,130.286 75,141 50,129 22,101 10,76 20.714,51 10,23 22)))
SELECT ST_MakeValid( 'LINESTRING(0 0,0 0)', 'method=structure keepcollapsed=true' );
PUNKT(0 0)
SELECT ST_MakeValid( 'LINESTRING(0 0,0 0)', 'method=structure keepcollapsed=false' );
LINESTRING TOM
Dessa funktioner arbetar med det spatiala referenssystemet för geometrier som definieras i tabellen spatial_ref_sys.
ST_InverseTransformPipeline — Returnerar en ny geometri med koordinater som transformerats till ett annat spatialt referenssystem med hjälp av inversen av en definierad pipeline för koordinattransformation.
geometry ST_InverseTransformPipeline(geometry geom, text pipeline, integer to_srid);
Returnerar en ny geometri med koordinater som transformerats till ett annat spatialt referenssystem med hjälp av en definierad pipeline för koordinattransformation i motsatt riktning.
Se ST_TransformPipeline för mer information om hur du skriver en transformationspipeline.
Tillgänglighet: 3.4.0
SRID för indatageometrin ignoreras och SRID för utdatageometrin sätts till noll om inte ett värde anges via den valfria parametern to_srid. När ST_TransformPipeline används körs pipelinen i framåtriktad riktning. Om du använder `ST_InverseTransformPipeline()` körs pipelinen i invers riktning.
Transformationer som använder pipelines är en specialiserad version av ST_Transform. I de flesta fall väljer `ST_Transform` rätt operationer för att konvertera mellan koordinatsystem, och bör därför föredras.
Ändra WGS 84 long lat till UTM 31N med hjälp av EPSG:16031-omvandlingen
This example transforms in the inverse direction.
SELECT ST_InverseTransformPipeline(
'POINT(426857.9877165967 5427937.523342293)'::geometry,
'urn:ogc:def:coordinateOperation:EPSG::16031'
) AS wgs_geom;POINT(2 48.99999999999999)
GDA2020 exempel.
This example uses ST_Transform with automatic selection of a conversion pipeline.
SELECT ST_Transform('SRID=4939;POINT(143.0 -37.0)'::geometry, 7844) AS gda2020_auto;POINT(143.00000635638918 -36.999986706128176)
ST_SetSRID — Ställ in SRID på en geometri.
geometry ST_SetSRID(geometry geom, integer srid);
Ställer in SRID på en geometri till ett visst heltalsvärde. Användbart för att konstruera avgränsande rutor för frågor.
![]() | |
Den här funktionen omvandlar inte geometrikoordinaterna på något sätt - den ställer bara in metadata som definierar det spatiala referenssystem som geometrin antas vara i. Använd ST_Transform om du vill omvandla geometrin till en ny projektion. |
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1.
Denna metod stöder cirkulära strängar och kurvor.
Mark a point as WGS 84 longitude/latitude.
SELECT ST_SetSRID(ST_Point(-123.365556, 48.428611), 4326) AS wgs84long_lat;
SRID=4326;POINT(-123.365556 48.428611)
Mark a point as WGS 84 longitude/latitude and then transform it to Web Mercator.
SELECT ST_Transform(ST_SetSRID(ST_Point(-123.365556, 48.428611), 4326), 3785) AS sphere_merc;
SRID=3785;POINT(-13732990.8753491 6178458.96425423)
ST_SRID — Returnerar den spatiala referensidentifieraren för en geometri.
integer ST_SRID(geometry g1);
Returnerar den spatiala referensidentifieraren för ST_Geometry enligt definitionen i tabellen spatial_ref_sys. Avsnitt 4.5, ”Spatiala referenssystem”
![]() | |
spatial_ref_sys-tabellen är en tabell som katalogiserar alla spatiala referenssystem som är kända för PostGIS och används för transformationer från ett spatialt referenssystem till ett annat. Det är därför viktigt att verifiera att du har rätt identifierare för det spatiala referenssystemet om du planerar att transformera dina geometrier. |
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s2.1.1.1
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.5
Denna metod stöder cirkulära strängar och kurvor.
SELECT ST_SRID(ST_GeomFromText('POINT(-71.1043 42.315)', 4326));st_srid
---------
4326
(1 row)ST_Transform — Returnerar en ny geometri med koordinater som transformerats till ett annat spatialt referenssystem.
geometry ST_Transform(geometry g1, integer srid);
geometry ST_Transform(geometry geom, text to_proj);
geometry ST_Transform(geometry geom, text from_proj, text to_proj);
geometry ST_Transform(geometry geom, text from_proj, integer to_srid);
Returnerar en ny geometri vars koordinater har omvandlats till ett annat spatialt referenssystem. Den spatiala destinationsreferensen to_srid kan identifieras med en giltig SRID heltalsparameter (dvs. den måste finnas i tabellen spatial_ref_sys ). Alternativt kan en spatial referens som definieras som en PROJ.4-sträng användas för to_proj och/eller from_proj, men dessa metoder är inte optimerade. Om det spatiala referenssystemet för destinationen uttrycks med en PROJ.4-sträng i stället för en SRID, kommer SRID för utdatageometrin att sättas till noll. Med undantag för funktioner med from_proj måste indatageometrier ha en definierad SRID.
ST_Transform förväxlas ofta med ST_SetSRID. ST_Transform ändrar faktiskt koordinaterna för en geometri från ett spatialt referenssystem till ett annat, medan ST_SetSRID() helt enkelt ändrar SRID-identifieraren för geometrin.
ST_Transform väljer automatiskt en lämplig konverteringspipeline med tanke på källans och målets spatiala referenssystem. För att använda en specifik konverteringsmetod, använd ST_TransformPipeline.
![]() | |
Kräver att PostGIS är kompilerat med PROJ-stöd. Använd PostGIS_Full_Version för att bekräfta att du har PROJ-stöd kompilerat. |
![]() | |
Om du använder mer än en transformation är det bra att ha ett funktionellt index på de vanligaste transformationerna för att dra nytta av indexanvändningen. |
![]() | |
Före 1.3.4 kraschade den här funktionen om den användes med geometrier som innehåller CURVES. Detta är åtgärdat i 1.3.4+ |
Förbättrad: 2.0.0 stöd för polyhedrala ytor infördes.
Förbättrad: 2.3.0 stöd för direkt PROJ.4-text infördes.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.6
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
Ändra Massachusetts statsplan US feet geometri till WGS 84 long lat
SELECT ST_Transform(
'SRID=2249;POLYGON((743238 2967416,743238 2967450,
743265 2967450,743265.625 2967416,743238 2967416))'::geometry,
4326) AS wgs_geom;
SRID=4326;POLYGON((-71.1776848522251 42.3902896512903,-71.17768437663261 42.390382947801015,-71.17758443054647 42.390382667791854,-71.17758259272304 42.390289364798825,-71.1776848522251 42.3902896512903))
3D Circular String example.
SELECT ST_Transform('SRID=2249;CIRCULARSTRING(743238 2967416 1,743238 2967450 2,743265 2967450 3,743265.625 2967416 3,743238 2967416 4)'::geometry,
4326);SRID=4326;CIRCULARSTRING(-71.1776848522251 42.3902896512903 1,-71.17768437663261 42.390382947801015 2,
-71.17758443054647 42.390382667791854 3,
-71.17758259272304 42.390289364798825 3,-71.1776848522251 42.3902896512903 4)
Exempel på hur man skapar ett partiellt funktionellt index. För tabeller där du inte är säker på att alla geometrier kommer att fyllas i är det bäst att använda ett partiellt index som utelämnar nollgeometrier, vilket både sparar utrymme och gör ditt index mindre och mer effektivt.
CREATE INDEX idx_geom_26986_parcels
ON parcels
USING gist
(ST_Transform(geom, 26986))
WHERE geom IS NOT NULL;
Exempel på användning av PROJ.4-text för att transformera med anpassade spatiala referenser.
Find intersection of two polygons near the North pole, using a custom Gnomic projection. See http://boundlessgeo.com/2012/02/flattening-the-peel/.
WITH data AS (
SELECT
ST_GeomFromText('POLYGON((170 50,170 72,-130 72,-130 50,170 50))', 4326) AS p1,
ST_GeomFromText('POLYGON((-170 68,-170 90,-141 90,-141 68,-170 68))', 4326) AS p2,
'+proj=gnom +ellps=WGS84 +lat_0=70 +lon_0=-160 +no_defs'::text AS gnom
)
SELECT ST_Transform(ST_Intersection(ST_Transform(p1, gnom), ST_Transform(p2, gnom)),
gnom, 4326)
FROM data;POLYGON((-140.9999840290591 73.42768865981984,-141 68,-170 68,-170.0000026915361 74.05492179637055,-140.9999840290591 73.42768865981984))
Ibland kan koordinattransformation som involverar en rutnätsförskjutning misslyckas, t.ex. om PROJ.4 inte har byggts med rutnätsförskjutningsfiler eller om koordinaten inte ligger inom det område för vilket rutnätsförskjutningen är definierad. Som standard kommer PostGIS att ge ett felmeddelande om det inte finns någon gridskiftfil, men detta beteende kan konfigureras per SRID antingen genom att testa olika to_proj-värden för PROJ.4-text eller genom att ändra proj4text-värdet i tabellen spatial_ref_sys.
Till exempel är proj4text-parametern +datum=NAD87 en kortform för följande +nadgrids-parameter:
+nadgrids=@conus, @alaska, @ntv2_0.gsb, @ntv1_can.dat
Prefixet @ innebär att inget fel rapporteras om filerna inte finns, men om slutet av listan nås utan att någon fil har varit lämplig (dvs. hittad och överlappande) så utfärdas ett fel.
Om du däremot vill säkerställa att åtminstone standardfilerna finns, men att en nolltransformation tillämpas om alla filer skannas utan träff, kan du använda:
+nadgrids=@conus, @alaska, @ntv2_0.gsb, @ntv1_can.dat, null
Null grid shift-filen är en giltig grid shift-fil som täcker hela världen och inte tillämpar någon förskjutning. Så för ett fullständigt exempel, om du ville ändra PostGIS så att transformationer till SRID 4267 som inte låg inom rätt intervall inte kastade ett ERROR, skulle du använda följande:
UPDATE spatial_ref_sys SET proj4text = '+proj=longlat +ellps=clrk66 +nadgrids=@conus,@alaska,@ntv2_0.gsb,@ntv1_can.dat,null +no_defs' WHERE srid = 4267;
ST_TransformPipeline — Returnerar en ny geometri med koordinater som transformerats till ett annat spatialt referenssystem med hjälp av en definierad pipeline för koordinattransformation.
geometry ST_TransformPipeline(geometry g1, text pipeline, integer to_srid);
Returnerar en ny geometri med koordinater som transformerats till ett annat spatialt referenssystem med hjälp av en definierad pipeline för koordinattransformation.
Transformationspipelines definieras med hjälp av något av följande strängformat:
urn:ogc:def:coordinateOperation:AUTHORITY::CODE. Observera att en enkel EPSG:CODE -sträng inte identifierar en koordinatoperation på ett unikt sätt: samma EPSG-kod kan användas för en CRS-definition.
En PROJ-pipeline-sträng av formen: +proj=pipeline .... Automatisk axelnormalisering kommer inte att tillämpas och vid behov måste den som ringer lägga till ytterligare ett pipelinesteg eller ta bort axelbytessteg.
Sammanlänkade operationer av formen: urn:ogc:def:coordinateOperation,coordinateOperation:EPSG::3895,coordinateOperation:EPSG::1618.
Tillgänglighet: 3.4.0
SRID för inmatningsgeometrin ignoreras och SRID för utdatageometrin kommer att sättas till noll om inte ett värde anges via den valfria parametern to_srid. När du använder `ST_TransformPipeline()` körs pipelinen i framåtriktad riktning. Om du använder ST_InverseTransformPipeline körs pipelinen i omvänd riktning.
Transformationer som använder pipelines är en specialiserad version av ST_Transform. I de flesta fall väljer `ST_Transform` rätt operationer för att konvertera mellan koordinatsystem, och bör därför föredras.
Ändra WGS 84 long lat till UTM 31N med hjälp av EPSG:16031-omvandlingen
This example transforms in the forward direction.
SELECT
ST_SetSRID(ST_TransformPipeline(
'SRID=4326;POINT(2 49)'::geometry,
'urn:ogc:def:coordinateOperation:EPSG::16031'
), 32631) AS utm_geom;SRID=32631;POINT(426857.9877165967 5427937.523342293)
This example transforms in the inverse direction.
SELECT
ST_SetSRID(ST_InverseTransformPipeline(
'SRID=32631;POINT(426857.9877165967 5427937.523342293)'::geometry,
'urn:ogc:def:coordinateOperation:EPSG::16031'
), 4326) AS wgs_geom;SRID=4326;POINT(2 48.99999999999999)
GDA2020 exempel.
This example uses ST_Transform with automatic selection of a conversion pipeline.
SELECT ST_Transform('SRID=4939;POINT(143.0 -37.0)'::geometry, 7844) AS gda2020_auto;POINT(143.00000635638918 -36.999986706128176)
Using a defined conversion (EPSG:8447)
SELECT
ST_TransformPipeline(
'SRID=4939;POINT(143.0 -37.0)'::geometry,
'urn:ogc:def:coordinateOperation:EPSG::8447'
) AS gda2020_code;POINT(143.0000063280214 -36.999986718287545)
This example uses a PROJ pipeline definition matching EPSG:8447, as returned from projinfo. Any axisswap steps must be removed.
SELECT
ST_TransformPipeline(
'SRID=4939;POINT(143.0 -37.0)'::geometry,
'+proj=pipeline
+step +proj=unitconvert +xy_in=deg +xy_out=rad
+step +proj=hgridshift +grids=au_icsm_GDA94_GDA2020_conformal_and_distortion.tif
+step +proj=unitconvert +xy_in=rad +xy_out=deg'
) AS gda2020_pipeline;POINT(143.0000063280214 -36.999986718287545)
postgis_srs_codes — Returnerar listan över SRS-koder som är associerade med den angivna myndigheten.
setof text postgis_srs_codes(text auth_name);
Returnerar en uppsättning av alla auth_srid för det angivna auth_name.
Tillgänglighet: 3.4.0
Proj version 6+
Ange de tio första koderna som är kopplade till myndigheten EPSG.
SELECT * FROM postgis_srs_codes('EPSG') ORDER BY 1 LIMIT 10;10156 10157 10158 10160 10162 10163 10164 10165 10166 10167
postgis_srs — Returnerar en metadatapost för den begärda myndigheten och srid.
setof record postgis_srs(text auth_name, text auth_srid);
Returnerar en metadatapost för den begärda auth_srid för det angivna auth_name. Posten kommer att innehålla auth_name, auth_srid, srname, srtext, proj4text och hörnen av användningsområdet, point_sw och point_ne.
Tillgänglighet: 3.4.0
Proj version 6+
Hämta metadata för EPSG:3005.
SELECT auth_name, auth_srid, srname,point_sw AS point_sw,point_ne AS point_ne
FROM postgis_srs('EPSG', '3005');postgis_srs_all — Returnera metadataposter för varje spatialt referenssystem i den underliggande Proj-databasen.
postgis_srs_all(void);
Returnerar en uppsättning av alla metadataposter i den underliggande Proj-databasen. Posterna kommer att ha auth_name, auth_srid, srname, srtext, proj4text och hörnen på användningsområdet, point_sw och point_ne.
Tillgänglighet: 3.4.0
Proj version 6+
Hämta de 10 första metadataposterna från databasen Proj.
SELECT auth_name, auth_srid, srname FROM postgis_srs_all() ORDER BY auth_name, auth_srid LIMIT 10;
auth_name | auth_srid | srname -----------+-----------+---------------------------------------------------------------------- EPSG | 10156 | ETRS89 + MSL UK & Ireland VORF08 depth EPSG | 10157 | ETRS89 + CD UK & Ireland VORF08 depth EPSG | 10158 | S34J-IRF EPSG | 10160 | S34J reconstruction east-orientated EPSG | 10162 | JGD2011 / Japan Plane Rectangular CS I + JGD2011 (vertical) height EPSG | 10163 | JGD2011 / Japan Plane Rectangular CS II + JGD2011 (vertical) height EPSG | 10164 | JGD2011 / Japan Plane Rectangular CS III + JGD2011 (vertical) height EPSG | 10165 | JGD2011 / Japan Plane Rectangular CS IV + JGD2011 (vertical) height EPSG | 10166 | JGD2011 / Japan Plane Rectangular CS V + JGD2011 (vertical) height EPSG | 10167 | JGD2011 / Japan Plane Rectangular CS VI + JGD2011 (vertical) height
postgis_srs_search — Returnera metadataposter för projicerade koordinatsystem som har användningsområden som helt innehåller parametern bounds.
setof record postgis_srs_search(geometry bounds, text auth_name=EPSG);
Returnerar en uppsättning metadataposter för projicerade koordinatsystem som har användningsområden som helt innehåller parametern bounds. Varje post kommer att innehålla auth_name, auth_srid, srname, srtext, proj4text och användningsområdets hörn, point_sw och point_ne.
Sökningen letar endast efter projicerade koordinatsystem och är avsedd för användare att utforska de möjliga system som fungerar för omfattningen av deras data.
Tillgänglighet: 3.4.0
Proj version 6+
Sök efter projicerade koordinatsystem i Louisiana.
SELECT auth_name, auth_srid, srname,point_sw AS point_sw,point_ne AS point_ne
FROM postgis_srs_search('SRID=4326;LINESTRING(-90 30,-91 31)')
WHERE auth_srid IN ('2801', '3452', '3457')
ORDER BY auth_name, auth_srid::integer
Skanna en tabell för maximal utsträckning och hitta projicerade koordinatsystem som kan passa.
WITH ext AS ( SELECT ST_Extent(geom) AS geom, Max(ST_SRID(geom)) AS srid FROM foo ) SELECT auth_name, auth_srid, srname, point_sw AS point_sw, point_ne AS point_ne FROM ext CROSS JOIN postgis_srs_search(ST_SetSRID(ext.geom, ext.srid)) LIMIT 3;
Dessa funktioner skapar geometriska objekt från olika text- eller binärformat.
ST_BdPolyFromText — Konstruera en polygon givet en godtycklig samling av slutna linestrings som en MultiLineString Well-Known textrepresentation.
geometry ST_BdPolyFromText(text WKT, integer srid);
Konstruera en polygon givet en godtycklig samling av slutna linestrings som en MultiLineString Well-Known textrepresentation.
![]() | |
Kastar ett fel om WKT inte är en MULTILINESTRING. Kastar ett fel om utdata är en MULTIPOLYGON; använd ST_BdMPolyFromText i så fall, eller se ST_BuildArea() för en Postgis-specifik metod. |
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s3.2.6.2
Utförs av GEOS-modulen.
Tillgänglighet: 1.1.0
ST_BdMPolyFromText — Konstruera en MultiPolygon givet en godtycklig samling av slutna linestrings som en MultiLineString text representation Well-Known text representation.
geometry ST_BdMPolyFromText(text WKT, integer srid);
Konstruera en polygon givet en godtycklig samling av slutna linestrings, polygoner, MultiLineStrings som Well-Known text representation.
![]() | |
Ger ett felmeddelande om WKT inte är en MULTILINESTRING. Tvingar fram MULTIPOLYGON-utdata även om resultatet egentligen bara består av en enda POLYGON; använd ST_BdPolyFromText om du är säker på att en enda POLYGON blir resultatet av operationen, eller se ST_BuildArea() för en Postgis-specifik metod. |
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s3.2.6.2
Utförs av GEOS-modulen.
Tillgänglighet: 1.1.0
ST_GeogFromText — Returnera ett angivet geografiskt värde från Well-Known Text representation or extended (WKT).
geography ST_GeogFromText(text EWKT);
Returnerar ett geografiskt objekt från den välkända texten eller den utökade välkända representationen. SRID 4326 antas om den inte är specificerad. Detta är ett alias för ST_GeographyFromText. Punkter uttrycks alltid i lång lat-form.
Add a WGS 84 geography point column to a table.
ALTER TABLE sometable ADD COLUMN geog geography(POINT, 4326);
Populate the geography column from longitude and latitude columns.
UPDATE sometable
SET geog = ST_GeogFromText('SRID=4326;POINT(' || lon || ' ' || lat || ')');Specify a geography point using EPSG:4267, NAD27.
SELECT ST_GeogFromText('SRID=4267;POINT(-77.0092 38.889588)');SRID=4267;POINT(-77.0092 38.889588)
ST_GeographyFromText — Returnera ett angivet geografiskt värde från Well-Known Text representation or extended (WKT).
geography ST_GeographyFromText(text EWKT);
Returnerar ett geografiskt objekt från den välkända textrepresentationen. SRID 4326 antas om den inte är specificerad.
ST_GeomCollFromText — Skapar en geometrisk samling från samlingen WKT med angiven SRID. Om SRID inte anges är standardvärdet 0.
geometry ST_GeomCollFromText(text WKT, integer srid);
geometry ST_GeomCollFromText(text WKT);
Skapar en geometrisk samling från WKT-representationen (Well-Known-Text) med angiven SRID. Om SRID inte anges är standardvärdet 0.
OGC SPEC 3.2.6.2 - alternativet SRID är från överensstämmelsesviten
Returnerar null om WKT inte är en GEOMETRYCOLLECTION
![]() | |
Om du är helt säker på att alla dina WKT-geometrier är samlingar ska du inte använda den här funktionen. Den är långsammare än ST_GeomFromText eftersom den lägger till ytterligare ett valideringssteg. |
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s3.2.6.2
Denna metod implementerar SQL/MM-specifikationen.
SELECT ST_GeomCollFromText('GEOMETRYCOLLECTION(POINT(1 2), LINESTRING(1 2,3 4))');ST_GeomFromEWKT — Returnera ett specificerat ST_Geometry-värde från Extended Well-Known Text representation (EWKT).
geometry ST_GeomFromEWKT(text EWKT);
Konstruerar ett PostGIS ST_Geometry-objekt från OGC Extended Well-Known text (EWKT)-representationen.
![]() | |
EWKT-formatet är inte en OGC-standard, utan ett PostGIS-specifikt format som inkluderar identifieraren för det spatiala referenssystemet (SRID) |
Förbättrad: 2.0.0 stöd för polyhedrala ytor och TIN infördes.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
Create a LineString with SRID 4269.
SELECT ST_GeometryType(geom) AS geometry_type, ST_SRID(geom) AS srid
FROM ST_GeomFromEWKT('SRID=4269;LINESTRING(-71.160281 42.258729,-71.160837 42.259113,-71.161144 42.25932)') AS geom;geometry_type | srid ---------------+------ ST_LineString | 4269 (1 row)
Create a MultiLineString with SRID 4269.
SELECT ST_GeometryType(geom) AS geometry_type, ST_SRID(geom) AS srid
FROM ST_GeomFromEWKT('SRID=4269;MULTILINESTRING((-71.160281 42.258729,-71.160837 42.259113,-71.161144 42.25932))') AS geom;geometry_type | srid ---------------------+------ ST_MultiLineString | 4269 (1 row)
Create a Point with SRID 4269.
SELECT ST_GeometryType(geom) AS geometry_type, ST_SRID(geom) AS srid
FROM ST_GeomFromEWKT('SRID=4269;POINT(-71.064544 42.28787)') AS geom;geometry_type | srid ---------------+------ ST_Point | 4269 (1 row)
Create a Polygon with SRID 4269.
SELECT ST_GeometryType(geom) AS geometry_type, ST_SRID(geom) AS srid
FROM ST_GeomFromEWKT('SRID=4269;POLYGON((-71.1776585052917 42.3902909739571,-71.1776820268866 42.3903701743239,
-71.1776063012595 42.3903825660754,-71.1775826583081 42.3903033653531,-71.1776585052917 42.3902909739571))') AS geom;geometry_type | srid ---------------+------ ST_Polygon | 4269 (1 row)
Create a MultiPolygon with SRID 4269.
SELECT ST_GeometryType(geom) AS geometry_type, ST_SRID(geom) AS srid
FROM ST_GeomFromEWKT('SRID=4269;MULTIPOLYGON(((-71.1031880899493 42.3152774590236,
-71.1031627617667 42.3152960829043,-71.102923838298 42.3149156848307,
-71.1023097974109 42.3151969047397,-71.1019285062273 42.3147384934248,
-71.102505233663 42.3144722937587,-71.10277487471 42.3141658254797,
-71.103113945163 42.3142739188902,-71.10324876416 42.31402489987,
-71.1033002961013 42.3140393340215,-71.1033488797549 42.3139495090772,
-71.103396240451 42.3138632439557,-71.1041521907712 42.3141153348029,
-71.1041411411543 42.3141545014533,-71.1041287795912 42.3142114839058,
-71.1041188134329 42.3142693656241,-71.1041112482575 42.3143272556118,
-71.1041072845732 42.3143851580048,-71.1041057218871 42.3144430686681,
-71.1041065602059 42.3145009876017,-71.1041097995362 42.3145589148055,
-71.1041166403905 42.3146168544148,-71.1041258822717 42.3146748022936,
-71.1041375307579 42.3147318674446,-71.1041492906949 42.3147711126569,
-71.1041598612795 42.314808571739,-71.1042515013869 42.3151287620809,
-71.1041173835118 42.3150739481917,-71.1040809891419 42.3151344119048,
-71.1040438678912 42.3151191367447,-71.1040194562988 42.3151832057859,
-71.1038734225584 42.3151140942995,-71.1038446938243 42.3151006300338,
-71.1038315271889 42.315094347535,-71.1037393329282 42.315054824985,
-71.1035447555574 42.3152608696313,-71.1033436658644 42.3151648370544,
-71.1032580383161 42.3152269126061,-71.103223066939 42.3152517403219,
-71.1031880899493 42.3152774590236)),
((-71.1043632495873 42.315113108546,-71.1043583974082 42.3151211109857,
-71.1043443253471 42.3150676015829,-71.1043850704575 42.3150793250568,-71.1043632495873 42.315113108546)))') AS geom;geometry_type | srid -------------------+------ ST_MultiPolygon | 4269 (1 row)
Create a 3D CircularString without an SRID.
SELECT ST_GeometryType(geom) AS geometry_type, ST_SRID(geom) AS srid
FROM ST_GeomFromEWKT('CIRCULARSTRING(220268 150415 1,220227 150505 2,220227 150406 3)') AS geom;geometry_type | srid --------------------+------ ST_CircularString | 0 (1 row)
Create a PolyhedralSurface without an SRID.
SELECT ST_GeometryType(geom) AS geometry_type, ST_SRID(geom) AS srid
FROM ST_GeomFromEWKT('POLYHEDRALSURFACE(
((0 0 0,0 0 1,0 1 1,0 1 0,0 0 0)),
((0 0 0,0 1 0,1 1 0,1 0 0,0 0 0)),
((0 0 0,1 0 0,1 0 1,0 0 1,0 0 0)),
((1 1 0,1 1 1,1 0 1,1 0 0,1 1 0)),
((0 1 0,0 1 1,1 1 1,1 1 0,0 1 0)),
((0 0 1,1 0 1,1 1 1,0 1 1,0 0 1))
)') AS geom;geometry_type | srid --------------------------+------ ST_PolyhedralSurface | 0 (1 row)
ST_GeomFromMARC21 — Tar MARC21/XML-geografiska data som indata och returnerar ett PostGIS-geometriobjekt.
geometry ST_GeomFromMARC21 ( text marcxml );
Denna funktion skapar en PostGIS-geometri från en MARC21/XML-post, som kan innehålla en POINT eller en POLYGON. Om det finns flera geografiska dataposter i samma MARC21/XML-post returneras en MULTIPOINT eller MULTIPOLYGON. Om posten innehåller blandade geometrityper returneras en GEOMETRYCOLLECTION. Den returnerar NULL om MARC21/XML-posten inte innehåller några geografiska data (datafield:034).
Stöd för LOC MARC21/XML-versioner:
Tillgänglighet: 3.3.0, kräver libxml2 2.6+
![]() | |
MARC21/XML Coded Cartographic Mathematical Data tillhandahåller för närvarande inte något sätt att beskriva det spatiala referenssystemet för de kodade koordinaterna, så denna funktion returnerar alltid en geometri med |
![]() | |
Återlämnade |
Konvertering av MARC21/XML geografiska data som innehåller en enda POINT kodad som hddd.dddddddd
SELECT ST_GeomFromMARC21(
'<record xmlns="http://www.loc.gov/MARC21/slim">
<leader
>00000nz a2200000nc 4500</leader>
<controlfield tag="001"
>040277569</controlfield>
<datafield tag="034" ind1=" " ind2=" ">
<subfield code="d"
>W004.500000</subfield>
<subfield code="e"
>W004.500000</subfield>
<subfield code="f"
>N054.250000</subfield>
<subfield code="g"
>N054.250000</subfield>
</datafield>
</record
>'
);
POINT(-4.5 54.25)
Konvertering av MARC21/XML geografiska data som innehåller en enda POLYGON kodad som hdddmmss
SELECT ST_GeomFromMARC21(
'<record xmlns="http://www.loc.gov/MARC21/slim">
<leader
>01062cem a2200241 a 4500</leader>
<controlfield tag="001"
> 84696781 </controlfield>
<datafield tag="034" ind1="1" ind2=" ">
<subfield code="a"
>a</subfield>
<subfield code="b"
>50000</subfield>
<subfield code="d"
>E0130600</subfield>
<subfield code="e"
>E0133100</subfield>
<subfield code="f"
>N0523900</subfield>
<subfield code="g"
>N0522300</subfield>
</datafield>
</record
>'
);
POLYGON((13.1 52.65,13.516666666666667 52.65,13.516666666666667 52.38333333333333,13.1 52.38333333333333,13.1 52.65))
Konvertering av geografiska data i MARC21/XML som innehåller en POLYGON och en POINT:
SELECT ST_GeomFromMARC21(
'<record xmlns="http://www.loc.gov/MARC21/slim">
<datafield tag="034" ind1="1" ind2=" ">
<subfield code="a"
>a</subfield>
<subfield code="b"
>50000</subfield>
<subfield code="d"
>E0130600</subfield>
<subfield code="e"
>E0133100</subfield>
<subfield code="f"
>N0523900</subfield>
<subfield code="g"
>N0522300</subfield>
</datafield>
<datafield tag="034" ind1=" " ind2=" ">
<subfield code="d"
>W004.500000</subfield>
<subfield code="e"
>W004.500000</subfield>
<subfield code="f"
>N054.250000</subfield>
<subfield code="g"
>N054.250000</subfield>
</datafield>
</record
>'
);
GEOMETRYCOLLECTION(POLYGON((13.1 52.65,13.516666666666667 52.65,13.516666666666667 52.38333333333333,13.1 52.38333333333333,13.1 52.65)), POINT(-4.5 54.25))
ST_GeometryFromText — Returns a geometry from Well-Known Text (WKT). Alias for ST_GeomFromText.
geometry ST_GeometryFromText(text WKT);
geometry ST_GeometryFromText(text WKT, integer srid);
This function is an alias for ST_GeomFromText and provides the same signatures.
Tillgänglighet: 1.2.2
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.40
ST_GeomFromText — Returnera ett specificerat ST_Geometry-värde från Well-Known Text representation (WKT).
geometry ST_GeomFromText(text WKT);
geometry ST_GeomFromText(text WKT, integer srid);
Konstruerar ett PostGIS ST_Geometry-objekt från OGC Well-Known-textrepresentationen.
![]() | |
Det finns två varianter av funktionen ST_GeomFromText. Den första tar ingen SRID och returnerar en geometri utan definierat spatialt referenssystem (SRID=0). Den andra tar en SRID som andra argument och returnerar en geometri som innehåller denna SRID som en del av sina metadata. |
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s3.2.6.2 - alternativet SRID är från överensstämmelsesviten.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.40
Denna metod stöder cirkulära strängar och kurvor.
![]() | |
Även om det inte är OGC-kompatibelt är ST_MakePoint snabbare än ST_GeomFromText och ST_PointFromText. Det är också lättare att använda för numeriska koordinatvärden. ST_Point är ett annat alternativ som liknar ST_MakePoint i hastighet och är OGC-kompatibelt, men stöder inte annat än 2D-punkter. |
Ändrad: 2.0.0 I tidigare versioner av PostGIS var ST_GeomFromText('GEOMETRYCOLLECTION(EMPTY)') tillåtet. Detta är nu olagligt i PostGIS 2.0.0 för att bättre överensstämma med SQL/MM-standarder. Detta ska nu skrivas som ST_GeomFromText('GEOMETRYCOLLECTION EMPTY')
Create a LineString with SRID 0.
SELECT ST_SRID(ST_GeomFromText('LINESTRING(-71.160281 42.258729,-71.160837 42.259113,-71.161144 42.25932)'));0
Create the same LineString with SRID 4269.
SELECT ST_SRID(ST_GeomFromText('LINESTRING(-71.160281 42.258729,-71.160837 42.259113,-71.161144 42.25932)', 4269));4269
Create a MultiLineString.
SELECT ST_GeometryType(ST_GeomFromText('MULTILINESTRING((-71.160281 42.258729,-71.160837 42.259113,-71.161144 42.25932))'));ST_MultiLineString
Create a Point.
SELECT ST_GeometryType(ST_GeomFromText('POINT(-71.064544 42.28787)'));ST_Point
Create a Polygon.
SELECT ST_GeometryType(ST_GeomFromText('POLYGON((-71.1776585052917 42.3902909739571,-71.1776820268866 42.3903701743239,
-71.1776063012595 42.3903825660754,-71.1775826583081 42.3903033653531,-71.1776585052917 42.3902909739571))'));ST_Polygon
Create a MultiPolygon with SRID 4326.
SELECT ST_GeometryType(ST_GeomFromText('MULTIPOLYGON(((-71.1031880899493 42.3152774590236,
-71.1031627617667 42.3152960829043,-71.102923838298 42.3149156848307,
-71.1023097974109 42.3151969047397,-71.1019285062273 42.3147384934248,
-71.102505233663 42.3144722937587,-71.10277487471 42.3141658254797,
-71.103113945163 42.3142739188902,-71.10324876416 42.31402489987,
-71.1033002961013 42.3140393340215,-71.1033488797549 42.3139495090772,
-71.103396240451 42.3138632439557,-71.1041521907712 42.3141153348029,
-71.1041411411543 42.3141545014533,-71.1041287795912 42.3142114839058,
-71.1041188134329 42.3142693656241,-71.1041112482575 42.3143272556118,
-71.1041072845732 42.3143851580048,-71.1041057218871 42.3144430686681,
-71.1041065602059 42.3145009876017,-71.1041097995362 42.3145589148055,
-71.1041166403905 42.3146168544148,-71.1041258822717 42.3146748022936,
-71.1041375307579 42.3147318674446,-71.1041492906949 42.3147711126569,
-71.1041598612795 42.314808571739,-71.1042515013869 42.3151287620809,
-71.1041173835118 42.3150739481917,-71.1040809891419 42.3151344119048,
-71.1040438678912 42.3151191367447,-71.1040194562988 42.3151832057859,
-71.1038734225584 42.3151140942995,-71.1038446938243 42.3151006300338,
-71.1038315271889 42.315094347535,-71.1037393329282 42.315054824985,
-71.1035447555574 42.3152608696313,-71.1033436658644 42.3151648370544,
-71.1032580383161 42.3152269126061,-71.103223066939 42.3152517403219,
-71.1031880899493 42.3152774590236)),
((-71.1043632495873 42.315113108546,-71.1043583974082 42.3151211109857,
-71.1043443253471 42.3150676015829,-71.1043850704575 42.3150793250568,-71.1043632495873 42.315113108546)))', 4326));ST_MultiPolygon
Create a CircularString.
SELECT ST_GeometryType(ST_GeomFromText('CIRCULARSTRING(220268 150415,220227 150505,220227 150406)'));ST_CircularString
ST_LineFromText — Skapar en geometri från en WKT-representation med angiven SRID. Om SRID inte anges är standardvärdet 0.
geometry ST_LineFromText(text WKT);
geometry ST_LineFromText(text WKT, integer srid);
Skapar en geometri från WKT med angiven SRID. Om SRID inte anges är standardvärdet 0. Om WKT som skickas in inte är en LINESTRING returneras null.
![]() | |
OGC SPEC 3.2.6.2 - valfri SRID är från överensstämmelsesviten. |
![]() | |
Om du vet att alla dina geometrier är LINESTRINGS är det mer effektivt att bara använda ST_GeomFromText. Detta anropar bara ST_GeomFromText och lägger till ytterligare validering att den returnerar en linestrings. |
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s3.2.6.2
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 7.2.8
SELECT ST_LineFromText('LINESTRING(1 2,3 4)') AS aline,
ST_LineFromText('POINT(1 2)') IS NULL AS null_return;aline | null_return
------------------------------------
LINESTRING(1 2,3 4) | t
ST_MLineFromText — Returnera ett specificerat ST_MultiLineString-värde från WKT-representation.
geometry ST_MLineFromText(text WKT, integer srid);
geometry ST_MLineFromText(text WKT);
Skapar en geometri från Well-Known-Text (WKT) med angiven SRID. Om SRID inte anges är standardvärdet 0.
OGC SPEC 3.2.6.2 - alternativet SRID är från överensstämmelsesviten
Returnerar null om WKT inte är en MULTILINESTRING
![]() | |
Om du är helt säker på att alla dina WKT-geometrier är punkter ska du inte använda den här funktionen. Den är långsammare än ST_GeomFromText eftersom den lägger till ytterligare ett valideringssteg. |
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s3.2.6.2
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 9.4.4
SELECT ST_MLineFromText('MULTILINESTRING((1 2,3 4),(4 5,6 7))');ST_MPointFromText — Skapar en geometri från WKT med den angivna SRID. Om SRID inte anges är standardvärdet 0.
geometry ST_MPointFromText(text WKT, integer srid);
geometry ST_MPointFromText(text WKT);
Skapar en geometri från WKT med den angivna SRID. Om SRID inte anges är standardvärdet 0.
OGC SPEC 3.2.6.2 - alternativet SRID är från överensstämmelsesviten
Returnerar null om WKT inte är en MULTIPOINT
![]() | |
Om du är helt säker på att alla dina WKT-geometrier är punkter ska du inte använda den här funktionen. Den är långsammare än ST_GeomFromText eftersom den lägger till ytterligare ett valideringssteg. |
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. 3.2.6.2
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 9.2.4
SELECT ST_MPointFromText('MULTIPOINT((1 2),(3 4))');
SELECT ST_MPointFromText('MULTIPOINT((-70.9590 42.1180),(-70.9611 42.1223))', 4326);ST_MPolyFromText — Skapar en MultiPolygon Geometry från WKT med den angivna SRID. Om SRID inte anges är standardvärdet 0.
geometry ST_MPolyFromText(text WKT, integer srid);
geometry ST_MPolyFromText(text WKT);
Skapar en MultiPolygon från WKT med den angivna SRID. Om SRID inte anges är standardvärdet 0.
OGC SPEC 3.2.6.2 - alternativet SRID är från överensstämmelsesviten
Kastar ett fel om WKT inte är en MULTIPOLYGON
![]() | |
Om du är helt säker på att alla dina WKT-geometrier är multipolygoner ska du inte använda den här funktionen. Den är långsammare än ST_GeomFromText eftersom den lägger till ytterligare ett valideringssteg. |
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s3.2.6.2
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 9.6.4
Create a 3D MultiPolygon with an interior ring and SRID 0.
SELECT ST_MPolyFromText(
'MULTIPOLYGON(((0 0 1,20 0 1,20 20 1,0 20 1,0 0 1),
(5 5 3,5 7 3,7 7 3,7 5 3,5 5 3)))'
);MULTIPOLYGON(((0 0 1,20 0 1,20 20 1,0 20 1,0 0 1),(5 5 3,5 7 3,7 7 3,7 5 3,5 5 3)))
Create a MultiPolygon with SRID 4326.
SELECT ST_MPolyFromText(
'MULTIPOLYGON(((-70.916 42.1002,-70.9468 42.0946,-70.9765 42.0872,
-70.9754 42.0875,-70.9749 42.0879,-70.9752 42.0881,-70.9754 42.0891,
-70.9758 42.0894,-70.9759 42.0897,-70.9759 42.0899,-70.9754 42.0902,
-70.9756 42.0906,-70.9753 42.0907,-70.9753 42.0917,-70.9757 42.0924,
-70.9755 42.0928,-70.9755 42.0942,-70.9751 42.0948,-70.9755 42.0953,
-70.9751 42.0958,-70.9751 42.0962,-70.9759 42.0983,-70.9767 42.0987,
-70.9768 42.0991,-70.9771 42.0997,-70.9771 42.1003,-70.9768 42.1005,
-70.977 42.1011,-70.9766 42.1019,-70.9768 42.1026,-70.9769 42.1033,
-70.9775 42.1042,-70.9773 42.1043,-70.9776 42.1043,-70.9778 42.1048,
-70.9773 42.1058,-70.9774 42.1061,-70.9779 42.1065,-70.9782 42.1078,
-70.9788 42.1085,-70.9798 42.1087,-70.9806 42.109,-70.9807 42.1093,
-70.9806 42.1099,-70.9809 42.1109,-70.9808 42.1112,-70.9798 42.1116,
-70.9792 42.1127,-70.979 42.1129,-70.9787 42.1134,-70.979 42.1139,
-70.9791 42.1141,-70.9987 42.1116,-71.0022 42.1273,-70.9408 42.1513,
-70.9315 42.1165,-70.916 42.1002)))',
4326
);SRID=4326;MULTIPOLYGON(((-70.916 42.1002,-70.9468 42.0946,-70.9765 42.0872,-70.9754 42.0875,-70.9749 42.0879,-70.9752 42.0881,-70.9754 42.0891,-70.9758 42.0894,-70.9759 42.0897,-70.9759 42.0899,-70.9754 42.0902,-70.9756 42.0906,-70.9753 42.0907,-70.9753 42.0917,-70.9757 42.0924,-70.9755 42.0928,-70.9755 42.0942,-70.9751 42.0948,-70.9755 42.0953,-70.9751 42.0958,-70.9751 42.0962,-70.9759 42.0983,-70.9767 42.0987,-70.9768 42.0991,-70.9771 42.0997,-70.9771 42.1003,-70.9768 42.1005,-70.977 42.1011,-70.9766 42.1019,-70.9768 42.1026,-70.9769 42.1033,-70.9775 42.1042,-70.9773 42.1043,-70.9776 42.1043,-70.9778 42.1048,-70.9773 42.1058,-70.9774 42.1061,-70.9779 42.1065,-70.9782 42.1078,-70.9788 42.1085,-70.9798 42.1087,-70.9806 42.109,-70.9807 42.1093,-70.9806 42.1099,-70.9809 42.1109,-70.9808 42.1112,-70.9798 42.1116,-70.9792 42.1127,-70.979 42.1129,-70.9787 42.1134,-70.979 42.1139,-70.9791 42.1141,-70.9987 42.1116,-71.0022 42.1273,-70.9408 42.1513,-70.9315 42.1165,-70.916 42.1002)))
ST_PointFromText — Skapar en punktgeometri från WKT med angiven SRID. Om SRID inte anges är standardvärdet okänt.
geometry ST_PointFromText(text WKT);
geometry ST_PointFromText(text WKT, integer srid);
Konstruerar ett PostGIS ST_Geometry-punktobjekt från OGC Well-Known-textrepresentationen. Om SRID inte anges är standardvärdet okänt (för närvarande 0). Om geometrin inte är en WKT-punktrepresentation returneras null. Om WKT är helt ogiltig, kastas ett fel.
![]() | |
Det finns 2 varianter av ST_PointFromText-funktionen, den första tar ingen SRID och returnerar en geometri utan definierat spatialt referenssystem. Den andra tar ett id för spatial referens som det andra argumentet och returnerar en ST_Geometry som innehåller denna srid som en del av dess metadata. SRID:en måste vara definierad i tabellen spatial_ref_sys. |
![]() | |
Om du är helt säker på att alla dina WKT-geometrier är punkter ska du inte använda den här funktionen. Den är långsammare än ST_GeomFromText eftersom den lägger till ytterligare ett valideringssteg. Om du bygger punkter från långa lat-koordinater och bryr dig mer om prestanda och noggrannhet än OGC-överensstämmelse, använd ST_MakePoint eller OGC-kompatibelt alias ST_Point. |
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s3.2.6.2 - alternativet SRID är från överensstämmelsesviten.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 6.1.8
Create a point with the default SRID 0.
SELECT ST_PointFromText('POINT(-71.064544 42.28787)');POINT(-71.064544 42.28787)
Create a point with SRID 4326.
SELECT ST_PointFromText('POINT(-71.064544 42.28787)', 4326);SRID=4326;POINT(-71.064544 42.28787)
ST_PolygonFromText — Skapar en geometri från WKT med den angivna SRID. Om SRID inte anges är standardvärdet 0.
geometry ST_PolygonFromText(text WKT);
geometry ST_PolygonFromText(text WKT, integer srid);
Skapar en geometri från WKT med angiven SRID. Om SRID inte anges är standardvärdet 0. Returnerar null om WKT inte är en polygon.
OGC SPEC 3.2.6.2 - alternativet SRID är från överensstämmelsesviten
![]() | |
Om du är helt säker på att alla dina WKT-geometrier är polygoner ska du inte använda den här funktionen. Den är långsammare än ST_GeomFromText eftersom den lägger till ytterligare ett valideringssteg. |
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s3.2.6.2
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 8.3.6
The result is returned as a native geometry. The documentation test runner compares that value directly with the readable EWKT shown below and uses the same geometry for the generated figure.
SELECT ST_PolygonFromText('POLYGON((-71.1776585052917 42.3902909739571,-71.1776820268866 42.3903701743239,
-71.1776063012595 42.3903825660754,-71.1775826583081 42.3903033653531,-71.1776585052917 42.3902909739571))');POLYGON((-71.1776585052917 42.3902909739571,-71.1776820268866 42.3903701743239,-71.1776063012595 42.3903825660754,-71.1775826583081 42.3903033653531,-71.1776585052917 42.3902909739571))
SELECT ST_PolygonFromText('POINT(1 2)') IS NULL AS point_is_notpoly;t
ST_WKTToSQL — Returns a geometry from Well-Known Text (WKT). SQL/MM alias for ST_GeomFromText.
geometry ST_WKTToSQL(text WKT);
This function is the SQL/MM alias for ST_GeomFromText with no SRID argument.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.34
LINESTRING from a WKB representation, optionally using a given SRID.LINESTRING from a WKB representation, optionally using a given SRID.ST_GeogFromWKB — Skapar en geografisk instans från en geometrisk representation av Well-Known Binary (WKB) eller utökad Well Known Binary (EWKB).
geography ST_GeogFromWKB(bytea wkb);
Funktionen ST_GeogFromWKB tar en välkänd binär representation (WKB) av en geometri eller PostGIS Extended WKB och skapar en instans av lämplig geograftyp. Denna funktion spelar samma roll som Geometry Factory i SQL.
Om SRID inte anges är standardvärdet 4326 (WGS 84 lång lat).
Denna metod stöder cirkulära strängar och kurvor.
Although bytea rep contains single \, these need to be escaped when inserting into a table.
SELECT ST_GeogFromWKB(E'\\001\\002\\000\\000\\000\\002\\000\\000\\000\\037\\205\\353Q\\270~\\\\\\300\\323Mb\\020X\\231C@\\020X9\\264\\310~\\\\\\300)\\\\\\217\\302\\365\\230C@');
LINESTRING(-113.98 39.198,-113.981 39.195)
ST_GeomFromEWKB — Returnera ett specificerat ST_Geometry-värde från Extended Well-Known Binary representation (EWKB).
geometry ST_GeomFromEWKB(bytea EWKB);
Constructs a PostGIS geometry from an Extended Well-Known Binary (EWKB) representation.
![]() | |
EWKB-formatet är inte en OGC-standard, utan ett PostGIS-specifikt format som inkluderar identifieraren för det spatiala referenssystemet (SRID) |
Förbättrad: 2.0.0 stöd för polyhedrala ytor och TIN infördes.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
This example constructs LINESTRING(-71.160281 42.258729,-71.160837 42.259113,-71.161144 42.25932) in NAD83 longitude/latitude (SRID 4269) from its EWKB representation.
PostgreSQL escape string syntax (E'...') always interprets backslash escapes. Each backslash therefore has to be doubled so that the bytea input parser receives the octal escapes.
SELECT ST_GeomFromEWKB((
E'\\001\\002\\000\\000\\040\\255\\020\\000\\000\\003\\000\\000\\000\\344\\112\\075' ||
E'\\013\\102\\312\\121\\300\\156\\303\\050\\010\\036\\041\\105\\100\\047\\277\\105' ||
E'\\047\\113\\312\\121\\300\\366\\173\\142\\235\\052\\041\\105\\100\\225\\174\\354' ||
E'\\056\\120\\312\\121\\300\\160\\231\\323\\145\\061\\041\\105\\100'
)::bytea);0102000020AD10000003000000E44A3D0B42CA51C06EC328081E21454027BF45274BCA51C0F67B629D2A214540957CEC2E50CA51C07099D36531214540
With standard_conforming_strings enabled (the default), ordinary string literals preserve backslashes. The same EWKB can therefore be written with a single backslash before each octal byte value.
SELECT ST_GeomFromEWKB((
'\001\002\000\000\040\255\020\000\000\003\000\000\000\344\112\075' ||
'\013\102\312\121\300\156\303\050\010\036\041\105\100\047\277\105' ||
'\047\113\312\121\300\366\173\142\235\052\041\105\100\225\174\354' ||
'\056\120\312\121\300\160\231\323\145\061\041\105\100'
)::bytea);0102000020AD10000003000000E44A3D0B42CA51C06EC328081E21454027BF45274BCA51C0F67B629D2A214540957CEC2E50CA51C07099D36531214540
ST_GeomFromWKB — Skapar en geometriinstans från en Well-Known Binary geometrirepresentation (WKB) och valfri SRID.
geometry ST_GeomFromWKB(bytea geom);
geometry ST_GeomFromWKB(bytea geom, integer srid);
Funktionen ST_GeomFromWKB tar en välkänd binär representation av en geometri och ettSRID(Spatial Reference System ID) och skapar en instans av lämplig geometrityp. Denna funktion spelar samma roll som Geometry Factory i SQL. Detta är ett alternativt namn för ST_WKBToSQL.
Om SRID inte anges är standardvärdet 0 (Okänd).
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s3.2.7.2 - den valfria SRID:en är från överensstämmelsesviten
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.41
Denna metod stöder cirkulära strängar och kurvor.
Although bytea rep contains single \, these need to be escaped when inserting into a table. Unless standard_conforming_strings is set to on.
SELECT ST_GeomFromWKB(E'\\001\\002\\000\\000\\000\\002\\000\\000\\000\\037\\205\\353Q\\270~\\\\\\300\\323Mb\\020X\\231C@\\020X9\\264\\310~\\\\\\300)\\\\\\217\\302\\365\\230C@', 4326);
SRID=4326;LINESTRING(-113.98 39.198,-113.981 39.195)
SELECT ST_GeomFromWKB(ST_AsEWKB('POINT(2 5)'::geometry)
);POINT(2 5)
ST_LineFromWKB — Creates a LINESTRING from a WKB representation, optionally using a given SRID.
geometry ST_LineFromWKB(bytea WKB);
geometry ST_LineFromWKB(bytea WKB, integer srid);
The ST_LineFromWKB function takes a Well-Known Binary (WKB) representation of a geometry and an optional Spatial Reference System ID (SRID), and creates a LINESTRING geometry. It is a type-specific geometry factory in SQL.
If an SRID is not specified, it defaults to 0. NULL is returned if the input bytea does not represent a LINESTRING geometry.
![]() | |
OGC SPEC 3.2.6.2 - valfri SRID är från överensstämmelsesviten. |
![]() | |
If you know all your geometries are |
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s3.2.6.2
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 7.2.9
SELECT ST_LineFromWKB(
ST_AsBinary(ST_GeomFromText('LINESTRING(1 2,3 4)'))
) AS aline,
ST_LineFromWKB(
ST_AsBinary(ST_GeomFromText('POINT(1 2)'))
) IS NULL AS null_return;aline | null_return
------------------------------------
LINESTRING(1 2,3 4) | t
ST_LinestringFromWKB — Creates a LINESTRING from a WKB representation, optionally using a given SRID.
geometry ST_LinestringFromWKB(bytea WKB);
geometry ST_LinestringFromWKB(bytea WKB, integer srid);
The ST_LinestringFromWKB function takes a Well-Known Binary (WKB) representation of a geometry and an optional Spatial Reference System ID (SRID), and creates a LINESTRING geometry. It is an alias for ST_LineFromWKB.
If an SRID is not specified, it defaults to 0. NULL is returned if the input bytea does not represent a LINESTRING geometry.
![]() | |
OGC SPEC 3.2.6.2 - valfri SRID är från överensstämmelsesviten. |
![]() | |
If you know all your geometries are |
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s3.2.6.2
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 7.2.9
SELECT ST_LinestringFromWKB(
ST_AsBinary(ST_GeomFromText('LINESTRING(1 2,3 4)'))
) AS aline,
ST_LinestringFromWKB(
ST_AsBinary(ST_GeomFromText('POINT(1 2)'))
) IS NULL AS null_return;aline | null_return ------------------------------------ LINESTRING(1 2,3 4) | t
ST_PointFromWKB — Skapar en geometri från WKB med den angivna SRID
geometry ST_GeomFromWKB(bytea geom);
geometry ST_GeomFromWKB(bytea geom, integer srid);
Funktionen ST_PointFromWKB tar en välkänd binär representation av geometri och ettSRID(Spatial Reference System ID) och skapar en instans av lämplig geometrityp - i detta fall en POINT-geometri. Denna funktion har samma roll som Geometry Factory i SQL.
Om en SRID inte anges är standardvärdet 0. NULL returneras om indatabytea inte representerar en POINT-geometri.
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s3.2.7.2
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 6.1.9
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
SELECT ST_PointFromWKB(ST_AsEWKB('POINT(2 5)'::geometry));POINT(2 5)
SELECT ST_PointFromWKB(ST_AsEWKB('LINESTRING(2 5,2 6)'::geometry));null
ST_WKBToSQL — Returns a geometry from Well-Known Binary (WKB). SQL/MM alias for ST_GeomFromWKB without an SRID argument.
geometry ST_WKBToSQL(bytea WKB);
This function is the SQL/MM alias for ST_GeomFromWKB with no SRID argument.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.36
ST_Box2dFromGeoHash — Returnerar en BOX2D från en GeoHash-sträng.
box2d ST_Box2dFromGeoHash(text geohash, integer precision=full_precision_of_geohash);
Returnerar en BOX2D från en GeoHash-sträng.
Om ingen precision anges returnerar ST_Box2dFromGeoHash en BOX2D baserad på full precision för den inmatade GeoHash-strängen.
Om precision anges kommer ST_Box2dFromGeoHash att använda så många tecken från GeoHash för att skapa BOX2D. Lägre precisionsvärden resulterar i större BOX2D och större värden ökar precisionen.
Tillgänglighet: 2.1.0
SELECT ST_Box2dFromGeoHash('9qqj7nmxncgyy4d0dbxqz0');BOX(-115.172816 36.114646,-115.172816 36.114646)
SELECT ST_Box2dFromGeoHash('9qqj7nmxncgyy4d0dbxqz0', 0);BOX(-180 -90,180 90)
SELECT ST_Box2dFromGeoHash('9qqj7nmxncgyy4d0dbxqz0', 10);BOX(-115.17282128334 36.1146408319473,-115.172810554504 36.1146461963654)
ST_GeomFromGeoHash — Returnerar en geometri från en GeoHash-sträng.
geometry ST_GeomFromGeoHash(text geohash, integer precision=full_precision_of_geohash);
Returnerar en geometri från en GeoHash-sträng. Geometrin kommer att vara en polygon som representerar GeoHash-gränserna.
Om ingen precision anges returnerar ST_GeomFromGeoHash en polygon baserad på full precision för den inmatade GeoHash-strängen.
Om precision anges kommer ST_GeomFromGeoHash att använda så många tecken från GeoHash för att skapa polygonen.
Tillgänglighet: 2.1.0
The cells are returned together so their relative sizes remain visible in a shared coordinate frame.
SELECT ST_GeomFromGeoHash('9qqj7nmxncgyy4d0dbxqz0', 4) AS "precision 4", ST_GeomFromGeoHash('9qqj7nmxncgyy4d0dbxqz0', 5) AS "precision 5", ST_GeomFromGeoHash('9qqj7nmxncgyy4d0dbxqz0', 6) AS "precision 6";ST_GeomFromGML — Tar som indata GML-representation av geometri och matar ut ett PostGIS-geometriobjekt
geometry ST_GeomFromGML(text geomgml);
geometry ST_GeomFromGML(text geomgml, integer srid);
Konstruerar ett PostGIS ST_Geometry-objekt från OGC GML-representationen.
ST_GeomFromGML fungerar endast för GML Geometry-fragment. Den ger ett felmeddelande om du försöker använda den på ett helt GML-dokument.
OGC GML-versioner stöds:
GML 3.2.1 namnrymd
GML 3.1.1 Simple Features profile SF-2 (med GML 3.1.0 och 3.0.0 bakåtkompatibilitet)
GML 2.1.2
OGC GML-standarder, se: http://www.opengeospatial.org/standards/gml::
Tillgänglighet: 1.5, kräver libxml2 1.6+
Förbättrad: 2.0.0 stöd för polyhedrala ytor och TIN infördes.
Förbättrad: 2.0.0 standard srid valfri parameter tillagd.
Enhanced: 3.7.0 support for GML ArcString, curved Ring, and CurvePolygon geometries was introduced.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
GML tillåter blandade dimensioner (t.ex. 2D och 3D inom samma MultiGeometry). Eftersom PostGIS-geometrier inte gör det konverterar ST_GeomFromGML hela geometrin till 2D om en saknad Z-dimension hittas en gång.
GML stöder blandade SRS inom samma MultiGeometry. Eftersom PostGIS-geometrier inte gör det, omprojicerar ST_GeomFromGML i detta fall alla subgeometrier till SRS-rotnoden. Om inget srsName-attribut finns tillgängligt för GML-rotnoden kastar funktionen ett fel.
ST_GeomFromGML-funktionen är inte pedantisk när det gäller en explicit GML-namnrymd. Du kan undvika att nämna det uttryckligen för vanliga användningar. Men du behöver det om du vill använda XLink-funktionen i GML.
A single geometry with srsName.
SELECT ST_AsEWKT(ST_GeomFromGML($$
<gml:LineString xmlns:gml="http://www.opengis.net/gml"
srsName="EPSG:4269">
<gml:coordinates>
-71.16028,42.258729 -71.160837,42.259112 -71.161143,42.25932
</gml:coordinates>
</gml:LineString>
$$));
SRID=4269;LINESTRING(-71.16028 42.258729,-71.160837 42.259112,-71.161143 42.25932)
XLink usage.
SELECT ST_AsEWKT(ST_GeomFromGML($$
<gml:LineString xmlns:gml="http://www.opengis.net/gml"
xmlns:xlink="http://www.w3.org/1999/xlink"
srsName="EPSG:4269">
<gml:pointProperty>
<gml:Point gml:id="p1"
><gml:pos
>-71.16028 42.258729</gml:pos
></gml:Point>
</gml:pointProperty>
<gml:pos
>-71.160837 42.259112</gml:pos>
<gml:pos
>-71.161143 42.258729</gml:pos>
<gml:pointProperty>
<gml:Point xlink:type="simple" xlink:href="#p1"/>
</gml:pointProperty>
</gml:LineString>
$$));
SRID=4269;LINESTRING(-71.16028 42.258729,-71.160837 42.259112,-71.161143 42.258729,-71.16028 42.258729)
Polyhedral Surface.
SELECT ST_AsEWKT(ST_GeomFromGML('
<gml:PolyhedralSurface xmlns:gml="http://www.opengis.net/gml">
<gml:polygonPatches>
<gml:PolygonPatch>
<gml:exterior>
<gml:LinearRing
><gml:posList srsDimension="3"
>0 0 0 0 0 1 0 1 1 0 1 0 0 0 0</gml:posList
></gml:LinearRing>
</gml:exterior>
</gml:PolygonPatch>
<gml:PolygonPatch>
<gml:exterior>
<gml:LinearRing
><gml:posList srsDimension="3"
>0 0 0 0 1 0 1 1 0 1 0 0 0 0 0</gml:posList
></gml:LinearRing>
</gml:exterior>
</gml:PolygonPatch>
<gml:PolygonPatch>
<gml:exterior>
<gml:LinearRing
><gml:posList srsDimension="3"
>0 0 0 1 0 0 1 0 1 0 0 1 0 0 0</gml:posList
></gml:LinearRing>
</gml:exterior>
</gml:PolygonPatch>
<gml:PolygonPatch>
<gml:exterior>
<gml:LinearRing
><gml:posList srsDimension="3"
>1 1 0 1 1 1 1 0 1 1 0 0 1 1 0</gml:posList
></gml:LinearRing>
</gml:exterior>
</gml:PolygonPatch>
<gml:PolygonPatch>
<gml:exterior>
<gml:LinearRing
><gml:posList srsDimension="3"
>0 1 0 0 1 1 1 1 1 1 1 0 0 1 0</gml:posList
></gml:LinearRing>
</gml:exterior>
</gml:PolygonPatch>
<gml:PolygonPatch>
<gml:exterior>
<gml:LinearRing
><gml:posList srsDimension="3"
>0 0 1 1 0 1 1 1 1 0 1 1 0 0 1</gml:posList
></gml:LinearRing>
</gml:exterior>
</gml:PolygonPatch>
</gml:polygonPatches>
</gml:PolyhedralSurface
>'));
POLYHEDRALSURFACE(((0 0 0,0 0 1,0 1 1,0 1 0,0 0 0)), ((0 0 0,0 1 0,1 1 0,1 0 0,0 0 0)), ((0 0 0,1 0 0,1 0 1,0 0 1,0 0 0)), ((1 1 0,1 1 1,1 0 1,1 0 0,1 1 0)), ((0 1 0,0 1 1,1 1 1,1 1 0,0 1 0)), ((0 0 1,1 0 1,1 1 1,0 1 1,0 0 1)))
ST_GeomFromGeoJSON — Tar som indata en geojson-representation av en geometri och matar ut ett PostGIS-geometriobjekt
geometry ST_GeomFromGeoJSON(text geomjson);
geometry ST_GeomFromGeoJSON(json geomjson);
geometry ST_GeomFromGeoJSON(jsonb geomjson);
Konstruerar ett PostGIS-geometriobjekt från GeoJSON-representationen.
ST_GeomFromGeoJSON fungerar endast för JSON Geometry-fragment. Den ger ett felmeddelande om du försöker använda den på ett helt JSON-dokument.
Enhanced: 3.0.0 parsad geometri har SRID=4326 som standard om inget annat anges.
Förbättrad: 2.5.0 kan nu acceptera json och jsonb som indata.
Tillgänglighet: 2.0.0 kräver - JSON-C >= 0.9
![]() | |
Om du inte har aktiverat JSON-C kommer du att få ett felmeddelande i stället för att se en utdata. Aktivera JSON-C genom att köra configure --with-jsondir=/path/to/json-c. Se Avsnitt 2.2.3, ”Bygg konfiguration” för mer information. |
Denna funktion stöder 3d och kommer inte att tappa z-index.
SELECT ST_GeomFromGeoJSON('{"type":"Point","coordinates":[-48.23456,20.12345]}') AS wkt;POINT(-48.23456 20.12345)
This example creates a 3D LineString.
SELECT ST_GeomFromGeoJSON('{"type":"LineString","coordinates":[[1,2,3],[4,5,6],[7,8,9]]}') AS wkt;LINESTRING Z (1 2 3,4 5 6,7 8 9)
ST_GeomFromKML — Tar som indata KML-representation av geometri och matar ut ett PostGIS-geometriobjekt
geometry ST_GeomFromKML(text geomkml);
Constructs a PostGIS geometry from an OGC KML representation.
ST_GeomFromKML fungerar endast för KML Geometry-fragment. Den ger ett felmeddelande om du försöker använda den på ett helt KML-dokument.
OGC KML-versioner stöds:
KML 2.2.0 Namnrymd
OGC KML-standarder, se: http://www.opengeospatial.org/standards/kml::
Tillgänglighet: 1.5, kräver libxml2 2.6+
Denna funktion stöder 3d och kommer inte att tappa z-index.
![]() | |
ST_GeomFromKML does not support SQL/MM curve geometries. |
A single LineString geometry.
SELECT ST_AsEWKT(ST_GeomFromKML($$
<LineString>
<coordinates
>-71.1663, 42.2614
-71.1667, 42.2616</coordinates>
</LineString>
$$));
SRID=4326;LINESTRING(-71.1663 42.2614,-71.1667 42.2616)
ST_GeomFromTWKB — Skapar en geometriinstans från en TWKB ("Tiny Well-Known Binary")-geometrirepresentation.
geometry ST_GeomFromTWKB(bytea twkb);
Funktionen ST_GeomFromTWKB tar en TWKB ("Tiny Well-Known Binary") geometrirepresentation (WKB) och skapar en instans av lämplig geometrityp.
SELECT ST_GeomFromTWKB(ST_AsTWKB('LINESTRING(126 34,127 35)'::geometry));LINESTRING(126 34, 127 35)
SELECT ST_GeomFromTWKB(E'\\x620002f7f40dbce4040105');
LINESTRING(-113.98 39.198,-113.981 39.195)
ST_GMLToSQL — Returns a geometry from GML. Alias for ST_GeomFromGML.
geometry ST_GMLToSQL(text geomgml);
geometry ST_GMLToSQL(text geomgml, integer srid);
This function is an alias for ST_GeomFromGML and provides the same signatures.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.50.
Tillgänglighet: 1.5, kräver libxml2 1.6+
Förbättrad: 2.0.0 stöd för polyhedrala ytor och TIN infördes.
Förbättrad: 2.0.0 standard srid valfri parameter tillagd.
Enhanced: 3.7.0 support for GML ArcString, curved Ring, and CurvePolygon geometries was introduced.
ST_LineFromEncodedPolyline — Skapar en LineString från en kodad polylinje.
geometry ST_LineFromEncodedPolyline(text polyline, integer precision=5);
Skapar en LineString från en kodad Polyline-sträng.
Valfri precision anger hur många decimaler som ska bevaras i Encoded Polyline. Värdet bör vara detsamma vid kodning och avkodning, annars blir koordinaterna felaktiga.
Se http://developers.google.com/maps/documentation/utilities/polylinealgorithm
Tillgänglighet: 2.2.0
This example creates a LineString from a polyline.
SELECT ST_LineFromEncodedPolyline('_p~iF~ps|U_ulLnnqC_mqNvxq`@');SRID=4326;LINESTRING(-120.2 38.5,-120.95 40.7,-126.453 43.252)
This example selects a different precision than the one used for polyline encoding.
SELECT ST_LineFromEncodedPolyline('_p~iF~ps|U_ulLnnqC_mqNvxq`@', 6);SRID=4326;LINESTRING(-12.02 3.85,-12.095 4.07,-12.6453 4.3252)
ST_PointFromGeoHash — Returnerar en punkt från en GeoHash-sträng.
point ST_PointFromGeoHash(text geohash, integer precision=full_precision_of_geohash);
Returnerar en punkt från en GeoHash-sträng. Punkten representerar mittpunkten i GeoHash.
Om ingen precision anges returnerar ST_PointFromGeoHash en punkt baserad på full precision för den inmatade GeoHash-strängen.
Om precision anges kommer ST_PointFromGeoHash att använda så många tecken från GeoHash för att skapa punkten.
Tillgänglighet: 2.1.0
SELECT ST_PointFromGeoHash('9qqj7nmxncgyy4d0dbxqz0');POINT(-115.172816 36.114646)
SELECT ST_PointFromGeoHash('9qqj7nmxncgyy4d0dbxqz0', 4);POINT(-115.13671875 36.123046875)
SELECT ST_PointFromGeoHash('9qqj7nmxncgyy4d0dbxqz0', 10);POINT(-115.172815918922 36.1146435141563)
ST_FromFlatGeobufToTable — Skapar en tabell baserad på strukturen i FlatGeobuf-data.
void ST_FromFlatGeobufToTable(text schemaname, text tablename, bytea FlatGeobuf input data);
Skapar en tabell baserad på strukturen i FlatGeobuf-data.(http://flatgeobuf.org).
schema Schemanamn.
table Tabellnamn.
data Ingång FlatGeobuf data.
Tillgänglighet: 3.2.0
ST_FromFlatGeobuf — Läser FlatGeobuf-data.
setof anyelement ST_FromFlatGeobuf(anyelement Table reference, bytea FlatGeobuf input data);
Läser FlatGeobuf-data(http://flatgeobuf.org). OBS: PostgreSQL bytea kan inte överstiga 1 GB.
tabletype referens till en tabelltyp.
datainmatning FlatGeobuf-data.
Tillgänglighet: 3.2.0
Dessa funktioner konverterar geometriska objekt till olika text- eller binärformat.
ST_AsEWKT — Returnera WKT-representationen (Well-Known Text) av geometrin med SRID-metadata.
text ST_AsEWKT(geometry g1);
text ST_AsEWKT(geometry g1, integer maxdecimaldigits=15);
text ST_AsEWKT(geography g1);
text ST_AsEWKT(geography g1, integer maxdecimaldigits=15);
Returnerar Well-Known Text-representationen av geometrin med SRID som prefix. Det valfria argumentet maxdecimaldigits kan användas för att minska det maximala antalet decimalsiffror efter flyttal som används i utdata (standard är 15).
För att utföra den omvända konverteringen av EWKT-representation till PostGIS-geometri använder du ST_GeomFromEWKT.
![]() | |
Om parametern |
![]() | |
WKT-specifikationen innehåller inte SRID. För att få OGC WKT-formatet använd ST_AsText. |
![]() | |
WKT-formatet upprätthåller inte precisionen, så för att förhindra flytande trunkering ska du använda ST_AsBinary eller ST_AsEWKB för transport. |
Förbättrad: 3.1.0 stöd för valfri precisionsparameter.
Förbättrad: 2.0.0 stöd för Geography, Polyhedral surfaces, Triangles och TIN infördes.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
SELECT ST_AsEWKT('0103000020e61000000100000005000000000000000000000000000000000000000000000000000000000000000000f03f000000000000f03f000000000000f03f000000000000f03f000000000000000000000000000000000000000000000000'::geometry);SRID=4326;POLYGON((0 0,0 1,1 1,1 0,0 0))
SELECT ST_AsEWKT('0108000080030000000000000060E30A4100000000785C0241000000000000F03F0000000018E20A4100000000485F024100000000000000400000000018E20A4100000000305C02410000000000000840');CIRCULARSTRING(220268 150415 1,220227 150505 2,220227 150406 3)
ST_AsText — Returnera WKT-representationen (Well-Known Text) av geometrin/geografin utan SRID-metadata.
text ST_AsText(geometry g1);
text ST_AsText(geometry g1, integer maxdecimaldigits = 15);
text ST_AsText(geography g1);
text ST_AsText(geography g1, integer maxdecimaldigits = 15);
Returnerar OGC Well-Known Text (WKT)-representationen av geometrin/geografin. Det valfria argumentet maxdecimaldigits kan användas för att begränsa antalet siffror efter decimaltecknet i utmatade ordinater (standard är 15).
För att utföra den omvända konverteringen av WKT-representation till PostGIS-geometri använder du ST_GeomFromText.
![]() | |
Den standardiserade OGC WKT-representationen innehåller inte SRID. Om du vill inkludera SRID som en del av utdatarepresentationen använder du den icke-standardiserade PostGIS-funktionen ST_AsEWKT |
![]() | |
Den textuella representationen av tal i WKT kanske inte upprätthåller full flyttalsprecision. För att säkerställa full noggrannhet vid lagring eller transport av data är det bäst att använda Well-Known Binary (WKB)-format (se ST_AsBinary och |
![]() | |
Om parametern |
Tillgänglighet: 1.5 - stöd för geografi infördes.
Förbättrad: 2.5 - valfri parameterprecision infördes.
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s2.1.1.1
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.25
Denna metod stöder cirkulära strängar och kurvor.
SELECT ST_AsText('01030000000100000005000000000000000000000000000000000000000000000000000000000000000000f03f000000000000f03f000000000000f03f000000000000f03f000000000000000000000000000000000000000000000000');POLYGON((0 0,0 1,1 1,1 0,0 0))
Fullständig precisionsutdata är standard.
SELECT ST_AsText('POINT(111.1111111 1.1111111)'::geometry);POINT(111.1111111 1.1111111)
Argumentet maxdecimaldigits kan användas för att begränsa precisionen i utdata.
SELECT ST_AsText('POINT(111.1111111 1.1111111)'::geometry, 2);POINT(111.11 1.11)
ST_AsBinary — Returnera OGC/ISO Well-Known Binary (WKB)-representationen av geometrin/geografin utan SRID-metadata.
bytea ST_AsBinary(geometry g1);
bytea ST_AsBinary(geometry g1, text NDR_or_XDR);
bytea ST_AsBinary(geography g1);
bytea ST_AsBinary(geography g1, text NDR_or_XDR);
Returnerar OGC/ISO Well-Known Binary (WKB)-representationen av geometrin. Den första funktionsvarianten använder som standard kodning med servermaskinens endian. Den andra funktionsvarianten tar ett textargument som anger endian-kodningen: antingen 'NDR' för little-endian eller 'XDR' för big-endian. Om du anger okända argument kommer utdata att resultera i little-endian.
WKB-formatet är användbart för att läsa geometridata från databasen och bibehålla full numerisk precision. På så sätt undviks den precisionsavrundning som kan förekomma med textformat som WKT.
För att utföra den omvända konverteringen av WKB till PostGIS-geometri använder du ST_GeomFromWKB.
![]() | |
OGC/ISO WKB-formatet innehåller inte SRID. För att få EWKB-formatet som innehåller SRID använder du ST_AsEWKB |
![]() | |
PostgreSQL outputs |
Förbättrad: 2.0.0 stöd för polyhedrala ytor, trianglar och TIN infördes.
Förbättrad: 2.0.0 stöd för högre koordinatdimensioner infördes.
Förbättrad: 2.0.0 stöd för att ange endian med geografi infördes.
Tillgänglighet: 1.5.0 stöd för geografi infördes.
Changed: 2.0.0 Inputs to this function can not be unknown -- must be geometry. Constructs such as ST_AsBinary('POINT(1 2)') are no longer valid and you will get an n ST_AsBinary(unknown) is not unique error. Code like that needs to be changed to ST_AsBinary('POINT(1 2)'::geometry);. If that is not possible, then install legacy.sql.
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s2.1.1.1
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.37
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
Denna funktion stöder 3d och kommer inte att tappa z-index.
SELECT ST_AsBinary(ST_GeomFromText('POLYGON((0 0,0 1,1 1,1 0,0 0))', 4326));\x01030000000100000005000000000000000000000000000000000000000000000000000000000000 000000f03f000000000000f03f000000000000f03f000000000000f03f0000000000000000000000 00000000000000000000000000
SELECT ST_AsBinary(ST_GeomFromText('POLYGON((0 0,0 1,1 1,1 0,0 0))', 4326), 'XDR');\x000000000300000001000000050000000000000000000000000000000000000000000000003ff000 00000000003ff00000000000003ff00000000000003ff00000000000000000000000000000000000 00000000000000000000000000
ST_AsEWKB — Returnerar EWKB-representationen (Extended Well-Known Binary) av geometrin med SRID-metadata.
bytea ST_AsEWKB(geometry g1);
bytea ST_AsEWKB(geometry g1, text NDR_or_XDR);
Returnerar EWKB-representationen ( Extended Well-Known Binary ) av geometrin med SRID-metadata. Den första funktionsvarianten använder som standard kodning med servermaskinens endian. Den andra funktionsvarianten tar ett textargument som anger endian-kodningen: antingen 'NDR' för little-endian eller 'XDR' för big-endian. Om du anger okända argument kommer utdata att resultera i little-endian.
WKB-formatet är användbart för att läsa geometridata från databasen och bibehålla full numerisk precision. På så sätt undviks den precisionsavrundning som kan förekomma med textformat som WKT.
För att utföra den inversa konverteringen av EWKB till PostGIS-geometri använd ST_GeomFromEWKB.
![]() | |
För att få OGC/ISO WKB-formatet använd ST_AsBinary. Observera att OGC/ISO WKB-formatet inte innehåller SRID. |
Förbättrad: 2.0.0 stöd för polyhedrala ytor, trianglar och TIN infördes.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
SELECT ST_AsEWKB(ST_GeomFromText('POLYGON((0 0,0 1,1 1,1 0,0 0))', 4326));\x0103000020e610000001000000050000000000000000000000000000000000000000000000000000 00000000000000f03f000000000000f03f000000000000f03f000000000000f03f00000000000000 0000000000000000000000000000000000
SELECT ST_AsEWKB(ST_GeomFromText('POLYGON((0 0,0 1,1 1,1 0,0 0))', 4326), 'XDR');\x0020000003000010e600000001000000050000000000000000000000000000000000000000000000 003ff00000000000003ff00000000000003ff00000000000003ff000000000000000000000000000 0000000000000000000000000000000000
ST_AsHEXEWKB — Returnerar en geometri i HEXEWKB-format (som text) med antingen little-endian (NDR) eller big-endian (XDR) kodning.
text ST_AsHEXEWKB(geometry g1, text NDRorXDR);
text ST_AsHEXEWKB(geometry g1);
Returnerar en geometri i HEXEWKB-format (som text) med antingen little-endian- (NDR) eller big-endian- (XDR) kodning. Om ingen kodning anges används NDR.
Tillgänglighet: 1.2.2
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
SELECT ST_AsHEXEWKB(ST_GeomFromText('POLYGON((0 0,0 1,1 1,1 0,0 0))', 4326));0103000020E6100000010000000500 00000000000000000000000000000000 00000000000000000000000000000000F03F 000000000000F03F000000000000F03F000000000000F03 F000000000000000000000000000000000000000000000000
Which gives the same answer as:
SELECT ST_GeomFromText('POLYGON((0 0,0 1,1 1,1 0,0 0))', 4326)::text;ST_AsEncodedPolyline — Returnerar en kodad polylinje från en LineString-geometri.
text ST_AsEncodedPolyline(geometry geom, integer precision=5);
Returns the geometry in the Encoded Polyline Algorithm Format. The format stores latitude and longitude deltas as integers after multiplying coordinates by 10 raised to the requested precision.
The informal names polyline5 and polyline6 refer to the same encoding with precision 5 and 6. The precision must match when encoding and decoding; otherwise the coordinates are scaled incorrectly.
The input geometry must use SRID 4326, with longitude as X and latitude as Y. Use ST_Transform to transform geometries in other coordinate systems before encoding.
The OSRM API returns precision 5 for geometries=polyline and precision 6 for geometries=polyline6. Decode the resulting route.geometry with ST_LineFromEncodedPolyline using the matching precision.
Tillgänglighet: 2.2.0
Encode the same WGS 84 LineString using precision 5 and 6.
WITH route AS (
SELECT ST_GeomFromEWKT(
'SRID=4326;LINESTRING(-120.2 38.5,-120.95 40.7,-126.453 43.252)'
) AS geom
)
SELECT ST_AsEncodedPolyline(geom, 5) AS polyline5,
ST_AsEncodedPolyline(geom, 6) AS polyline6
FROM route;
polyline5 | polyline6
-----------------------------+----------------------------------
_p~iF~ps|U_ulLnnqC_mqNvxq`@ | _izlhA~rlgdF_{geC~ywl@_kwzCn`{nIDecode an OSRM route.geometry returned with geometries=polyline6.
SELECT ST_AsEWKT(ST_LineFromEncodedPolyline(
'_izlhA~rlgdF_{geC~ywl@_kwzCn`{nI',
6
)) AS route;
SRID=4326;LINESTRING(-120.2 38.5,-120.95 40.7,-126.453 43.252)
The Google Maps JavaScript Geometry library decodes precision-5 strings. This browser example assumes that map is an initialized Google map.
<script src="https://maps.googleapis.com/maps/api/js?key=YOUR_API_KEY&libraries=geometry"
></script>
<script>
const encodedPath = "_p~iF~ps|U_ulLnnqC_mqNvxq`@";
const flightPath = new google.maps.Polyline({
path: google.maps.geometry.encoding.decodePath(encodedPath),
map: map,
strokeColor: "#0000CC",
strokeOpacity: 1.0,
strokeWeight: 4
});
</script>
ST_AsFlatGeobuf — Returnerar en FlatGeobuf-representation av en uppsättning rader.
bytea ST_AsFlatGeobuf(anyelement set row);
bytea ST_AsFlatGeobuf(anyelement row, bool index);
bytea ST_AsFlatGeobuf(anyelement row, bool index, text geom_name);
Returnera en FlatGeobuf-representation(http://flatgeobuf.org) av en uppsättning rader som motsvarar en FeatureCollection. OBS: PostgreSQL bytea kan inte överstiga 1 GB.
rad raddata med minst en geometrikolumn.
index växlar spatialt indexskapande. Standard är false.
geom_name är namnet på geometrikolumnen i raddata. Om NULL används som standard den första geometrikolumnen som hittas.
Tillgänglighet: 3.2.0
ST_AsGeobuf — Returnerar en Geobuf-representation av en uppsättning rader.
bytea ST_AsGeobuf(anyelement set row);
bytea ST_AsGeobuf(anyelement row, text geom_name);
Returnerar en Geobuf-representation(https://github.com/mapbox/geobuf) av en uppsättning rader som motsvarar en FeatureCollection. Varje inmatad geometri analyseras för att bestämma maximal precision för optimal lagring. Observera att Geobuf i sin nuvarande form inte kan strömmas, så hela utdata kommer att samlas i minnet.
rad raddata med minst en geometrikolumn.
geom_name är namnet på geometrikolumnen i raddata. Om NULL används som standard den första geometrikolumnen som hittas.
Tillgänglighet: 2.4.0
SELECT encode(ST_AsGeobuf(q, 'geom'), 'base64') FROM (SELECT 'POLYGON((0 0,0 1,1 1,1 0,0 0))'::geometry AS geom) AS q;
GAAiEAoOCgwIBBoIAAAAAgIAAAE=
ST_AsGeoJSON — Returnerar en geometri eller funktion i GeoJSON-format.
text ST_AsGeoJSON(record feature, text geom_column="", integer maxdecimaldigits=9, boolean pretty_bool=false, text id_column='');
text ST_AsGeoJSON(geometry geom, integer maxdecimaldigits=9, integer options=8);
text ST_AsGeoJSON(geography geog, integer maxdecimaldigits=9, integer options=0);
Returnerar en geometri som ett GeoJSON "geometry"-objekt eller en rad som ett GeoJSON "feature"-objekt.
De resulterande GeoJSON-geometri- och funktionsrepresentationerna överensstämmer med GeoJSON-specifikationerna RFC 7946, utom när de analyserade geometrierna refereras med en annan CRS än WGS84-longitud och latitud(EPSG:4326, urn:ogc:def:crs:OGC::CRS84); GeoJSON-geometriobjektet kommer då att ha en kort CRS SRID-identifierare bifogad som standard. både 2D- och 3D-geometrier stöds. GeoJSON stöder endast SFS 1.1 geometrityper (inget stöd för kurvor t.ex.).
Parametern geom_column används för att skilja mellan flera geometrikolumner. Om den utelämnas kommer den första geometrikolumnen i posten att bestämmas. Omvänt sparar man kolumntypssökningar om man skickar parametern.
Argumentet maxdecimaldigits kan användas för att minska det maximala antalet decimaler som används i utdata (standard är 9). Om du använder EPSG:4326 och endast matar ut geometrin för visning, kan maxdecimaldigits=6 vara ett bra val för många kartor.
![]() | |
Om parametern |
Argumentet options kan användas för att lägga till BBOX eller CRS i GeoJSON-utdata:
0: innebär inget alternativ
1: GeoJSON BBOX
2: GeoJSON Short CRS (t.ex. EPSG:4326)
4: GeoJSON Long CRS (t.ex. urn:ogc:def:crs:EPSG::4326)
8: GeoJSON Short CRS om inte EPSG:4326 (standard)
Parametern id_column används för att ställa in medlemmen "id" i de returnerade GeoJSON-funktionerna. Enligt GeoJSON RFC BÖR detta användas när en funktion har en allmänt använd identifierare, t.ex. en primärnyckel. Om den inte anges kommer de producerade funktionerna inte att få någon "id"-medlem och alla andra kolumner än geometrin, inklusive eventuella nycklar, kommer bara att hamna i funktionens "properties"-medlem.
When the input record includes duplicate column names, the resulting "properties" object will contain repeated keys. ST_AsGeoJSON raises a warning in that case because PostgreSQL jsonb keeps only the last value for duplicate keys.
The GeoJSON specification states that polygons are oriented using the Right-Hand Rule, and some clients require this orientation. This can be ensured by using ST_ForcePolygonCCW. The specification also requires that geometry be in the WGS84 coordinate system (SRID = 4326). If necessary geometry can be projected into WGS84 using ST_Transform: ST_Transform(geom, 4326 ).
GeoJSON kan testas och ses online på geojson.io och geojsonlint.com. Det stöds i stor utsträckning av ramverk för webbkartläggning:
Tillgänglighet: 1.3.4
Tillgänglighet: 1.5.0 stöd för geografi infördes.
Ändrad: 2.0.0 stödjer standard args och namngivna args.
Ändrat: 3.0.0 stödjer poster som indata
Ändrat: 3.0.0 mata ut SRID om inte EPSG:4326.
Ändrad: 3.5.0 gör det möjligt att ange kolumnen som innehåller funktionens id
Changed: 3.7.0 added warning about duplicate keys
Denna funktion stöder 3d och kommer inte att tappa z-index.
Generera en FeatureCollection:
SELECT json_build_object(
'type', 'FeatureCollection',
'features', json_agg(ST_AsGeoJSON(t.*, id_column =
> 'id')::json)
)
FROM ( VALUES (1, 'one', 'POINT(1 1)'::geometry),
(2, 'two', 'POINT(2 2)'),
(3, 'three', 'POINT(3 3)')
) as t(id, name, geom);{"type" : "FeatureCollection", "features" : [{"type": "Feature", "geometry": {"type":"Point","coordinates":[1,1]}, "id": 1, "properties": {"name": "one"}}, {"type": "Feature", "geometry": {"type":"Point","coordinates":[2,2]}, "id": 2, "properties": {"name": "two"}}, {"type": "Feature", "geometry": {"type":"Point","coordinates":[3,3]}, "id": 3, "properties": {"name": "three"}}]}Skapa en funktion:
SELECT ST_AsGeoJSON(t.*, id_column = > 'id') FROM (VALUES (1, 'one', 'POINT(1 1)'::geometry)) AS t(id, name, geom);
{"type": "Feature", "geometry": {"type":"Point","coordinates":[1,1]}, "id": 1, "properties": {"name": "one"}}Glöm inte att omvandla dina data till WGS84-longitud, latitud för att överensstämma med GeoJSON-specifikationen:
SELECT ST_AsGeoJSON(ST_Transform(geom, 4326)) FROM fe_edges LIMIT 1;
{"type":"MultiLineString","coordinates":[[[-89.734634999999997,31.492072000000000],
[-89.734955999999997,31.492237999999997]]]}
stöd för 3D-geometrier:
SELECT ST_AsGeoJSON('LINESTRING(1 2 3,4 5 6)');{"type":"LineString","coordinates":[[1,2,3],[4,5,6]]}Options-argumentet kan användas för att lägga till BBOX och CRS i GeoJSON-utdata:
SELECT ST_AsGeoJSON(ST_SetSRID('POINT(1 1)'::geometry, 4326), 9, 4|1);{"type":"Point","crs":{"type":"name","properties":{"name":"urn:ogc:def:crs:EPSG::4326"}},"bbox":[1.000000000,1.000000000,1.000000000,1.000000000],"coordinates":[1,1]}
ST_AsGML — Returnera geometrin som ett GML-element version 2 eller 3.
text ST_AsGML(geometry geom, integer maxdecimaldigits=15, integer options=0);
text ST_AsGML(geography geog, integer maxdecimaldigits=15, integer options=0, text nprefix=null, text id=null);
text ST_AsGML(integer version, geometry geom, integer maxdecimaldigits=15, integer options=0, text nprefix=null, text id=null);
text ST_AsGML(integer version, geography geog, integer maxdecimaldigits=15, integer options=0, text nprefix=null, text id=null);
Returnerar geometrin som ett GML-element (Geography Markup Language). Versionsparametern, om den anges, kan vara antingen 2 eller 3. Om ingen versionsparameter anges antas standardvärdet vara 2. Argumentet maxdecimaldigits kan användas för att minska det maximala antalet decimaler som används i utdata (standard är 15).
![]() | |
Om parametern |
GML 2 hänvisar till version 2.1.2, GML 3 till version 3.1.1
Argumentet "options" är ett bitfält. Det kan användas för att definiera CRS-utdatatyp i GML-utdata och för att deklarera data som lat/lon:
0: GML Short CRS (t.ex. EPSG:4326), standardvärde
1: GML Long CRS (t.ex. urn:ogc:def:crs:EPSG::4326)
2: Endast för GML 3, ta bort srsDimension-attributet från utdata.
4: Endast för GML 3, använd <LineString> i stället för <Curve> tagg för linjer.
16: Ange att data är lat/lon (t.ex. srid=4326). Standard är att anta att data är planarer. Detta alternativ är endast användbart för GML 3.1.1-utdata, relaterat till axelordning. Så om du anger det kommer koordinaterna att bytas så att ordningen blir lat lon istället för databas lon lat.
32: Utdata av geometrins box (kuvert).
Argumentet "namespace prefix" kan användas för att ange ett eget namnrymdsprefix eller inget prefix (om det är tomt). Om null eller utelämnat används "gml"-prefixet
Tillgänglighet: 1.3.2
Tillgänglighet: 1.5.0 stöd för geografi infördes.
Förbättrad: Stöd för prefix 2.0.0 har införts. Alternativ 4 för GML3 infördes för att tillåta användning av LineString istället för Curve-tagg för linjer. GML3-stöd för polyedriska ytor och TINS infördes. Alternativ 32 infördes för att mata ut boxen.
Ändrad: 2.0.0 använder standardnamn för args
Förbättrad: 2.1.0 id-stöd infördes för GML 3.
![]() | |
Endast version 3+ av ST_AsGML stöder polyhedrala ytor och TINS. |
Denna metod implementerar SQL/MM-specifikationen. SQL-MM IEC 13249-3: 17.2
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
Version 2.
SELECT ST_AsGML(ST_GeomFromText('POLYGON((0 0,0 1,1 1,1 0,0 0))', 4326));<gml:Polygon srsName="EPSG:4326" ><gml:outerBoundaryIs ><gml:LinearRing ><gml:coordinates >0,0 0,1 1,1 1,0 0,0</gml:coordinates ></gml:LinearRing ></gml:outerBoundaryIs ></gml:Polygon >
Version 3.
Flip coordinates and output extended EPSG (16 | 1)
SELECT ST_AsGML(3, ST_GeomFromText('POINT(5.234234233242 6.34534534534)', 4326), 5, 17);<gml:Point srsName="urn:ogc:def:crs:EPSG::4326" ><gml:pos srsDimension="2" >6.34535 5.23423</gml:pos ></gml:Point >
Output the envelope (32).
SELECT ST_AsGML(3, ST_GeomFromText('LINESTRING(1 2, 3 4, 10 20)',4326), 5, 32);<gml:Envelope srsName="EPSG:4326" srsDimension="2" ><gml:lowerCorner >1 2</gml:lowerCorner ><gml:upperCorner >10 20</gml:upperCorner ></gml:Envelope >
Output the envelope (32), reverse (lat lon instead of lon lat) (16), long srs (1) = 32 | 16 | 1 = 49.
SELECT ST_AsGML(3, ST_GeomFromText('LINESTRING(1 2, 3 4, 10 20)',4326), 5, 49);<gml:Envelope srsName="urn:ogc:def:crs:EPSG::4326" srsDimension="2" ><gml:lowerCorner >2 1</gml:lowerCorner ><gml:upperCorner >20 10</gml:upperCorner ></gml:Envelope >
This example uses a PolyhedralSurface.
SELECT ST_AsGML( 3, 'POLYHEDRALSURFACE( ((0 0 0, 0 0 1, 0 1 1, 0 1 0, 0 0 0)), ((0 0 0, 0 1 0, 1 1 0, 1 0 0, 0 0 0)), ((0 0 0, 1 0 0, 1 0 1, 0 0 1, 0 0 0)), ((1 1 0, 1 1 1, 1 0 1, 1 0 0, 1 1 0)), ((0 1 0, 0 1 1, 1 1 1, 1 1 0, 0 1 0)), ((0 0 1, 1 0 1, 1 1 1, 0 1 1, 0 0 1)) )'::geometry);
<gml:PolyhedralSurface>
<gml:polygonPatches>
<gml:PolygonPatch>
<gml:exterior>
<gml:LinearRing>
<gml:posList srsDimension="3"
>0 0 0 0 0 1 0 1 1 0 1 0 0 0 0</gml:posList>
</gml:LinearRing>
</gml:exterior>
</gml:PolygonPatch>
<gml:PolygonPatch>
<gml:exterior>
<gml:LinearRing>
<gml:posList srsDimension="3"
>0 0 0 0 1 0 1 1 0 1 0 0 0 0 0</gml:posList>
</gml:LinearRing>
</gml:exterior>
</gml:PolygonPatch>
<gml:PolygonPatch>
<gml:exterior>
<gml:LinearRing>
<gml:posList srsDimension="3"
>0 0 0 1 0 0 1 0 1 0 0 1 0 0 0</gml:posList>
</gml:LinearRing>
</gml:exterior>
</gml:PolygonPatch>
<gml:PolygonPatch>
<gml:exterior>
<gml:LinearRing>
<gml:posList srsDimension="3"
>1 1 0 1 1 1 1 0 1 1 0 0 1 1 0</gml:posList>
</gml:LinearRing>
</gml:exterior>
</gml:PolygonPatch>
<gml:PolygonPatch>
<gml:exterior>
<gml:LinearRing>
<gml:posList srsDimension="3"
>0 1 0 0 1 1 1 1 1 1 1 0 0 1 0</gml:posList>
</gml:LinearRing>
</gml:exterior>
</gml:PolygonPatch>
<gml:PolygonPatch>
<gml:exterior>
<gml:LinearRing>
<gml:posList srsDimension="3"
>0 0 1 1 0 1 1 1 1 0 1 1 0 0 1</gml:posList>
</gml:LinearRing>
</gml:exterior>
</gml:PolygonPatch>
</gml:polygonPatches>
</gml:PolyhedralSurface
>ST_AsKML — Returnera geometrin som ett KML-element.
text ST_AsKML(geometry geom, integer maxdecimaldigits=15, text nprefix=NULL);
text ST_AsKML(geography geog, integer maxdecimaldigits=15, text nprefix=NULL);
Returnera geometrin som ett Keyhole Markup Language (KML)-element. standard maximalt antal decimaler är 15, standard namnrymd är inget prefix.
![]() | |
Om parametern |
Tillgänglighet: 1.2.2 - senare varianter som innehåller version param kom i 1.3.2
Förbättrad: 2.0.0 - Lägg till prefixnamnrymd, använd standard- och namngivna args
Ändrad: 3.0.0 - Variantsignaturen "versioned" har tagits bort
![]() | |
Kräver att PostGIS är kompilerat med Proj-stöd. Använd PostGIS_Full_Version för att bekräfta att du har proj-stöd kompilerat. |
![]() | |
AsKML-utdata fungerar inte med geometrier som inte har en SRID |
Denna funktion stöder 3d och kommer inte att tappa z-index.
SELECT ST_AsKML(ST_GeomFromText('POLYGON((0 0,0 1,1 1,1 0,0 0))', 4326));<Polygon ><outerBoundaryIs ><LinearRing ><coordinates >0,0 0,1 1,1 1,0 0,0</coordinates ></LinearRing ></outerBoundaryIs ></Polygon >
This example outputs a 3D LineString.
SELECT ST_AsKML('SRID=4326;LINESTRING(1 2 3,4 5 6)');<LineString ><coordinates >1,2,3 4,5,6</coordinates ></LineString >
ST_AsLatLonText — Returnerar grader, minuter och sekunder för den angivna punkten.
text ST_AsLatLonText(geometry pt, text format='');
Returnerar grader, minuter och sekunder för punkten.
![]() | |
Det antas att punkten befinner sig i en lat/lon-projektion. Koordinaterna X (lon) och Y (lat) normaliseras i utdata till det "normala" intervallet (-180 till +180 för lon, -90 till +90 för lat). |
Parametern text är en formatsträng som innehåller formatet för den resulterande texten, på samma sätt som en datumformatsträng. Giltiga symboler är "D" för grader, "M" för minuter, "S" för sekunder och "C" för kardinalriktning (NSEW). DMS-tokens kan upprepas för att ange önskad bredd och precision ("SSS.SSSS" betyder "1,0023").
"M", "S" och "C" är valfria. Om "C" utelämnas visas grader med ett "-"-tecken om det är söder eller väster. Om "S" utelämnas visas minuter som decimaltal med så många precisionssiffror som du anger. Om "M" också utelämnas visas grader som decimaltal med så många siffrors precision som du anger.
Om formatsträngen utelämnas (eller är noll-lång) kommer ett standardformat att användas.
Tillgänglighet: 2.0
Standardformat.
SELECT (ST_AsLatLonText('POINT (-3.2342342 -2.32498)'));2°19'29.928"S 3°14'3.243"W
Tillhandahåller ett format (samma som standard).
SELECT (ST_AsLatLonText('POINT (-3.2342342 -2.32498)', 'D°M''S.SSS"C'));2°19'29.928"S 3°14'3.243"W
Andra tecken än D, M, S, C och . passeras bara igenom.
SELECT (ST_AsLatLonText('POINT (-3.2342342 -2.32498)', 'D degrees, M minutes, S seconds to the C'));2 degrees, 19 minutes, 30 seconds to the S 3 degrees, 14 minutes, 3 seconds to the W
Signerade grader istället för kardinalriktningar.
SELECT (ST_AsLatLonText('POINT (-3.2342342 -2.32498)', 'D°M''S.SSS"'));-2°19'29.928" -3°14'3.243"
Decimala grader.
SELECT (ST_AsLatLonText('POINT (-3.2342342 -2.32498)', 'D.DDDD degrees C'));2.3250 degrees S 3.2342 degrees W
Alltför stora värden normaliseras.
SELECT (ST_AsLatLonText('POINT (-302.2342342 -792.32498)'));72°19'29.928"S 57°45'56.757"E
ST_AsMARC21 — Returnerar geometri som en MARC21/XML-post med ett geografiskt datafält (034).
text ST_AsMARC21 ( geometry geom , text format='hdddmmss' );
Denna funktion returnerar en MARC21/XML-post med kodade kartografiska matematiska data som representerar den begränsande boxen för en given geometri. Formatparametern gör det möjligt att koda koordinaterna i underfälten $d,$e,$f och $g i alla format som stöds av MARC21/XML-standarden. Giltiga format är:
kardinalriktning, grader, minuter och sekunder (standard): hdddmmss
decimalgrader med kardinalriktning: hddd.dddddd
decimalgrader utan kardinalriktning: ddd.dddddddd
decimalminuter med kardinalriktning: hdddmm.mmmm
decimalminuter utan kardinalriktning: dddmm.mmmm
decimalsekunder med kardinalriktning: hdddmmss.sss
Decimaltecknet kan också vara ett kommatecken, t.ex. hdddmm,mmmm..
Precisionen i decimalformat kan begränsas av antalet tecken efter decimaltecknet, t.ex. hdddmm.mm för decimala minuter med en precision på två decimaler.
Denna funktion ignorerar Z- och M-dimensionerna.
Stöd för LOC MARC21/XML-versioner:
Tillgänglighet: 3.3.0
![]() | |
Denna funktion stöder inte geometrier som inte är lon/lat, eftersom de inte stöds av MARC21/XML-standarden (Coded Cartographic Mathematical Data). |
![]() | |
MARC21/XML-standarden tillhandahåller inte något sätt att kommentera det spatiala referenssystemet för kodade kartografiska matematiska data, vilket innebär att denna information kommer att gå förlorad efter konvertering till MARC21/XML. |
Konvertera en POINT till MARC21/XML formaterad som hdddmmss (standard)
SELECT ST_AsMARC21('SRID=4326;POINT(-4.504289 54.253312)'::geometry);
st_asmarc21
-------------------------------------------------
<record xmlns="http://www.loc.gov/MARC21/slim">
<datafield tag="034" ind1="1" ind2=" ">
<subfield code="a"
>a</subfield>
<subfield code="d"
>W0043015</subfield>
<subfield code="e"
>W0043015</subfield>
<subfield code="f"
>N0541512</subfield>
<subfield code="g"
>N0541512</subfield>
</datafield>
</record>
Konvertering av en POLYGON till MARC21/XML formaterad i decimalgrader
SELECT ST_AsMARC21('SRID=4326;POLYGON((-4.5792388916015625 54.18172660239091,-4.56756591796875 54.196993557130355,-4.546623229980469 54.18313300502024,-4.5792388916015625 54.18172660239091))'::geometry,'hddd.dddd');
<record xmlns="http://www.loc.gov/MARC21/slim">
<datafield tag="034" ind1="1" ind2=" ">
<subfield code="a"
>a</subfield>
<subfield code="d"
>W004.5792</subfield>
<subfield code="e"
>W004.5466</subfield>
<subfield code="f"
>N054.1970</subfield>
<subfield code="g"
>N054.1817</subfield>
</datafield>
</record>
Konvertering av en GEOMETRYCOLLECTION till MARC21/XML formaterad i decimalminuter. Geometriernas ordning i MARC21/XML-utdata motsvarar deras ordning i samlingen.
SELECT ST_AsMARC21('SRID=4326;GEOMETRYCOLLECTION(POLYGON((13.1 52.65,13.516666666666667 52.65,13.516666666666667 52.38333333333333,13.1 52.38333333333333,13.1 52.65)),POINT(-4.5 54.25))'::geometry,'hdddmm.mmmm');
st_asmarc21
-------------------------------------------------
<record xmlns="http://www.loc.gov/MARC21/slim">
<datafield tag="034" ind1="1" ind2=" ">
<subfield code="a"
>a</subfield>
<subfield code="d"
>E01307.0000</subfield>
<subfield code="e"
>E01331.0000</subfield>
<subfield code="f"
>N05240.0000</subfield>
<subfield code="g"
>N05224.0000</subfield>
</datafield>
<datafield tag="034" ind1="1" ind2=" ">
<subfield code="a"
>a</subfield>
<subfield code="d"
>W00430.0000</subfield>
<subfield code="e"
>W00430.0000</subfield>
<subfield code="f"
>N05415.0000</subfield>
<subfield code="g"
>N05415.0000</subfield>
</datafield>
</record>
ST_AsMVTGeom — Transformerar en geometri till koordinatrymden för en MVT-platta.
geometry ST_AsMVTGeom(geometry geom, box2d bounds, integer extent=4096, integer buffer=256, boolean clip_geom=true);
Transformerar en geometri till koordinatrymden för en MVT-karta(Mapbox Vector Tile) och klipper den till kartans gränser om så krävs. Geometrin måste vara i målkartans koordinatsystem (med hjälp av ST_Transform om det behövs). Vanligtvis är detta Web Mercator (SRID:3857).
Funktionen försöker bevara geometrins validitet och korrigerar den vid behov. Detta kan leda till att resultatgeometrin kollapsar till en lägre dimension.
The function performs geometry simplification appropriate to the integer tile coordinate space. After transforming to tile coordinates it snaps coordinates to the integer grid, removes repeated points, and removes points that lie on straight lines. It does not perform general-purpose, scale-dependent simplification such as ST_Simplify. To reduce detail before tile conversion, simplify the geometry in map coordinates before calling ST_AsMVTGeom.
De rektangulära gränserna för plattan i målkartans koordinatrum måste anges, så att geometrin kan transformeras och klippas vid behov. Gränserna kan genereras med hjälp av ST_TileEnvelope.
Denna funktion används för att konvertera geometrin till det koordinatutrymme för plattor som krävs av ST_AsMVT.
geom är den geometri som ska transformeras, i målkartans koordinatsystem.
bounds är de rektangulära gränserna för plattan i kartkoordinatrymden, utan buffert.
extent är storleken på plattans extent i plattans koordinatutrymme enligt definitionen i MVT-specifikationen. Standardvärdet är 4096.
buffer är buffertstorleken i plattkoordinatrymden för geometriklippning. Standardvärdet är 256.
clip_geom är en boolean som styr om geometrier ska klippas eller kodas som de är. Standardvärdet är true.
Tillgänglighet: 2.4.0
![]() | |
Från och med 3.0 kan Wagyu väljas vid konfigurationstillfället för att klippa och validera MVT-polygoner. Det här biblioteket är snabbare och ger mer korrekta resultat än GEOS standard, men det kan tappa små polygoner. |
SELECT ST_AsMVTGeom('POLYGON ((0 0,10 0,10 5,0 -5,0 0))',
ST_MakeBox2D(ST_Point(0, 0), ST_Point(4096, 4096)),
4096, 0, false);MULTIPOLYGON(((5 4096,10 4091,10 4096,5 4096)),((5 4096,0 4101,0 4096,5 4096)))
Kanoniskt exempel för en Web Mercator-platta som använder en beräknad plattgräns för att fråga och klippa geometri. Detta förutsätter att data.geom-kolumnen har srid på 4326.
SELECT ST_AsMVTGeom(ST_Transform(geom, 3857 ),
ST_TileEnvelope(12, 513, 412),
extent =
> 4096,
buffer =
> 64) AS geom
FROM data
WHERE geom && ST_Transform(ST_TileEnvelope(12, 513, 412, margin =
> (64.0 / 4096)), 4326)
ST_AsMVT — Aggregatfunktion som returnerar en MVT-representation av en uppsättning rader.
bytea ST_AsMVT(anyelement set row);
bytea ST_AsMVT(anyelement row, text name);
bytea ST_AsMVT(anyelement row, text name, integer extent);
bytea ST_AsMVT(anyelement row, text name, integer extent, text geom_name);
bytea ST_AsMVT(anyelement row, text name, integer extent, text geom_name, text feature_id_name);
En aggregerad funktion som returnerar en binär Mapbox Vector Tile-representation av en uppsättning rader som motsvarar ett plattlager. Raderna måste innehålla en geometrikolumn som kommer att kodas som en funktionsgeometri. Geometrin måste vara i plattkoordinatrymden och giltig enligt MVT-specifikationen. ST_AsMVTGeom kan användas för att omvandla geometrin till plattkoordinatrymden. Övriga kolumner i raden kodas som attribut för objektet.
Mapbox Vector Tile-format kan lagra funktioner med varierande uppsättningar attribut. För att använda den här funktionen måste du ange en JSONB-kolumn i raddata som innehåller Json-objekt på en nivås djup. Nycklarna och värdena i JSONB-värdena kommer att kodas som funktionsattribut.
Plattor med flera lager kan skapas genom att sammanfoga flera anrop till denna funktion med hjälp av || eller STRING_AGG.
![]() | |
Anropa inte med en |
rad raddata med minst en geometrikolumn.
name är namnet på lagret. Default är strängen "default".
extent är plattans utsträckning i skärmutrymme enligt specifikationens definition. Standardvärdet är 4096.
geom_name är namnet på geometrikolumnen i raddata. Standard är den första geometrikolumnen. Observera att PostgreSQL som standard automatiskt viker icke-citerade identifierare till gemener, vilket innebär att om inte geometrikolumnen är citerad, t.ex. "MyMVTGeom", måste denna parameter tillhandahållas som gemener.
feature_id_name är namnet på kolumnen Feature ID i raddata. Om NULL eller negativt anges inte Feature ID. Den första kolumnen som matchar namn och giltig typ (smallint, integer, bigint) kommer att användas som Feature ID, och alla efterföljande kolumner kommer att läggas till som en egenskap. JSON-egenskaper stöds inte.
Förbättrad: 3.0 - stöd för Feature ID har lagts till.
Förbättrad: 2.5.0 - stöd för parallella frågor har lagts till.
Tillgänglighet: 2.4.0
WITH mvtgeom AS
(
SELECT ST_AsMVTGeom(geom, ST_TileEnvelope(12, 513, 412), extent =
> 4096, buffer =
> 64) AS geom, name, description
FROM points_of_interest
WHERE geom && ST_TileEnvelope(12, 513, 412, margin =
> (64.0 / 4096))
)
SELECT ST_AsMVT(mvtgeom.*)
FROM mvtgeom;
ST_AsSVG — Returnerar SVG-banedata för en geometri.
text ST_AsSVG(geometry geom, integer rel=0, integer maxdecimaldigits=15);
text ST_AsSVG(geography geog, integer rel=0, integer maxdecimaldigits=15);
Returnerar geometrin som SVG-banedata (Scalar Vector Graphics). Använd 1 som andra argument om du vill att sökvägsdata ska implementeras i form av relativa förflyttningar, standard (eller 0) använder absoluta förflyttningar. Det tredje argumentet kan användas för att minska det maximala antalet decimaler som används i utdata (standard är 15). Punktgeometrier kommer att återges som cx/cy när 'rel'-argumentet är 0, x/y när 'rel' är 1. Multipoint-geometrier avgränsas med kommatecken (","), GeometryCollection-geometrier avgränsas med semikolon (";").
För att arbeta med PostGIS SVG-grafik, kolla in biblioteket pg_svg som innehåller plpgsql-funktioner för att arbeta med utdata från ST_AsSVG.
Förbättrad: 3.4.0 för stöd för alla kurvtyper
Ändrad: 2.0.0 för att använda standardargs och stödja namngivna args
Tillgänglighet: 1.2.2. Tillgänglighet: 1.4.0 Ändrat i PostGIS 1.4.0 för att inkludera L-kommandot i absolut sökväg för att överensstämma med http://www.w3.org/TR/SVG/paths.html#PathDataBNF
Denna metod stöder cirkulära strängar och kurvor.
SELECT ST_AsSVG('POLYGON((0 0,0 1,1 1,1 0,0 0))'::geometry);M 0 0 L 0 -1 1 -1 1 0 Z
Cirkulär sträng
SELECT ST_AsSVG('CIRCULARSTRING(-2 0,0 2,2 0,0 2,2 4)'::geometry);M -2 0 A 2 2 0 0 1 2 0 A 2 2 0 0 1 2 -4
Multi-kurva
SELECT ST_AsSVG('MULTICURVE((5 5,3 5,3 3,0 3),
CIRCULARSTRING(0 0,2 1,2 2))'::geometry, 0, 0);M 5 -5 L 3 -5 3 -3 0 -3 M 0 0 A 2 2 0 0 0 2 -2
Flera ytor
SELECT ST_AsSVG('MULTISURFACE(
CURVEPOLYGON(CIRCULARSTRING(-2 0,-1 -1,0 0,1 -1,2 0,0 2,-2 0),
(-1 0,0 0.5,1 0,0 1,-1 0)),
((7 8,10 10,6 14,4 11,7 8)))'::geometry, 0, 2);M -2 0 A 1 1 0 0 0 0 0 A 1 1 0 0 0 2 0 A 2 2 0 0 0 -2 0 Z M -1 0 L 0 -0.5 1 0 0 -1 -1 0 Z M 7 -8 L 10 -10 6 -14 4 -11 Z
ST_AsTWKB — Returnerar geometrin som TWKB, aka "Tiny Well-Known Binary"
bytea ST_AsTWKB(geometry geom, integer prec=0, integer prec_z=0, integer prec_m=0, boolean with_sizes=false, boolean with_boxes=false);
bytea ST_AsTWKB(geometry[] geom, bigint[] ids, integer prec=0, integer prec_z=0, integer prec_m=0, boolean with_sizes=false, boolean with_boxes=false);
Returnerar geometrin i TWKB-format (Tiny Well-Known Binary). TWKB är ett komprimerat binärt format med fokus på att minimera storleken på utdata.
Parametrarna för decimalsiffror styr hur mycket precision som lagras i utdata. Som standard avrundas värden till närmaste enhet före kodning. Om du vill överföra mer precision ökar du antalet. Ett värde på 1 innebär t.ex. att den första siffran till höger om decimaltecknet bevaras.
Parametrarna sizes och bounding boxes styr om valfri information om objektets kodade längd och objektets gränser ska inkluderas i utdata. Som standard är de inte det. Aktivera dem inte om inte din klientprogramvara har användning för dem, eftersom de bara tar upp utrymme (och att spara utrymme är själva poängen med TWKB).
Funktionens array-input-form används för att konvertera en samling geometrier och unika identifierare till en TWKB-samling som bevarar identifierarna. Detta är användbart för klienter som förväntar sig att packa upp en samling och sedan få tillgång till ytterligare information om objekten inuti. Du kan skapa matriserna med hjälp av funktionen array_agg. De andra parametrarna fungerar på samma sätt som för den enkla formen av funktionen.
![]() | |
Formatspecifikationen finns tillgänglig online på https://github.com/TWKB/Specification, och kod för att bygga en JavaScript-klient finns på https://github.com/TWKB/twkb.js.. |
Förbättrad: 2.4.0 minnes- och hastighetsförbättringar.
Tillgänglighet: 2.2.0
SELECT ST_AsTWKB('LINESTRING(1 1,5 5)'::geometry);\x02000202020808
För att skapa ett aggregerat TWKB-objekt inklusive identifierare aggregerar du först de önskade geometrierna och objekten med hjälp av "array_agg()" och anropar sedan lämplig TWKB-funktion.
SELECT ST_AsTWKB(array_agg(geom), array_agg(gid)) FROM mytable;
\x040402020400000202
ST_GeomFromTWKB, ST_AsBinary, ST_AsEWKB, ST_AsEWKT, ST_GeomFromText
ST_AsX3D — Returnerar en geometri i X3D xml-nodelementformat: ISO-IEC-19776-1.2-X3DEncodings-XML
text ST_AsX3D(geometry g1, integer maxdecimaldigits=15, integer options=0);
Returnerar en geometri som ett X3D xml-formaterat nodelement http://www.web3d.org/standards/number/19776-1. Om maxdecimaldigits (precision) inte anges är standardvärdet 15.
![]() | |
Det finns olika alternativ för att översätta PostGIS-geometrier till X3D eftersom X3D-geometrityper inte mappar direkt till PostGIS-geometrityper och några nyare X3D-typer som kan vara bättre mappningar som vi har undvikit eftersom de flesta renderingsverktyg för närvarande inte stöder dem. Det här är de mappningar vi har bestämt oss för. Skicka gärna en buggbiljett om du har tankar om idén eller sätt som vi kan låta människor ange sina föredragna mappningar. Nedan visas hur vi för närvarande mappar PostGIS 2D/3D-typer till X3D-typer |
The 'options' argument is a bitfield that denotes whether to represent coordinates with the X3D GeoCoordinates geospatial node and whether to flip the x/y axis. By default, ST_AsX3D outputs in database form (long,lat or X,Y), but the X3D default of lat/lon, y/x may be preferred.
0: X/Y i databasordning (t.ex. long/lat = X,Y är standard databasordning), standardvärde och icke-spatiala koordinater (bara vanliga gamla Coordinate-taggar).
1: Vänd X och Y. Om det används tillsammans med alternativomkopplaren GeoCoordinate kommer utdata att vara standard "latitude_first" och koordinaterna kommer också att vändas.
2: Utdata av koordinater i GeoSpatial GeoCoordinates. Detta alternativ kommer att ge ett fel om geometrierna inte är i WGS 84 long lat (srid: 4326). Detta är för närvarande den enda GeoCoordinate-typen som stöds. Se X3D-specifikationerna som anger ett spatialt referenssystem. Standardutdata kommer att vara GeoCoordinate geoSystem='"GD" "WE" "longitude_first"'. Om du föredrar X3D-standarden GeoCoordinate geoSystem='"GD" "WE" "latitude_first" ' använder du (2 + 1) = 3
| PostGIS-typ | 2D X3D Typ | 3D X3D Typ |
|---|---|---|
| LINESTRING | ännu inte implementerad - kommer att vara PolyLine2D | Linjeuppsättning |
| MULTILINESTRING | ännu inte implementerad - kommer att vara PolyLine2D | IndexeradLineSet |
| MULTIPOINT | Polypunkt2D | PointSet |
| PUNKT | matar ut de utrymmesavgränsade koordinaterna | matar ut de utrymmesavgränsade koordinaterna |
| (MULTI) POLYGON, POLYHEDRALSYTA | Ogiltig X3D-markup | IndexedFaceSet (inre ringar som för närvarande matas ut som en annan faceset) |
| TIN | TriangleSet2D (ännu ej implementerad) | IndexeradTriangeluppsättning |
![]() | |
stöd för 2D-geometri ännu inte komplett. Inre ringar ritas för närvarande bara som separata polygoner. Vi arbetar på dessa. |
Många framsteg sker inom 3D-rymden, särskilt med X3D Integration med HTML5
Det finns också en trevlig X3D-visare med öppen källkod som du kan använda för att visa renderade geometrier. Gratis Wrl http://freewrl.sourceforge.net/ binärfiler tillgängliga för Mac, Linux och Windows. Använd FreeWRL_Launcher-paketet för att visa geometrierna.
Kolla också in PostGIS minimalistiska X3D-visningsprogram som använder den här funktionen och x3dDom html/js open source toolkit.
Tillgänglighet: 2.0.0: ISO-IEC-19776-1.2-X3DEncodings-XML
Förbättrad: 2.2.0: Stöd för GeoCoordinates och vändning av axlar (x/y, long/lat). Titta på alternativ för detaljer.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
Create a complete X3D document containing a cube that is viewable in FreeWRL and other X3D viewers.
SELECT '<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE X3D PUBLIC "ISO//Web3D//DTD X3D 3.0//EN" "http://www.web3d.org/specifications/x3d-3.0.dtd">
<X3D>
<Scene>
<Transform>
<Shape>
<Appearance>
<Material emissiveColor=''0 0 1''/>
</Appearance
> ' ||
ST_AsX3D(ST_GeomFromEWKT('POLYHEDRALSURFACE( ((0 0 0, 0 0 1, 0 1 1, 0 1 0, 0 0 0)),
((0 0 0, 0 1 0, 1 1 0, 1 0 0, 0 0 0)), ((0 0 0, 1 0 0, 1 0 1, 0 0 1, 0 0 0)),
((1 1 0, 1 1 1, 1 0 1, 1 0 0, 1 1 0)),
((0 1 0, 0 1 1, 1 1 1, 1 1 0, 0 1 0)), ((0 0 1, 1 0 1, 1 1 1, 0 1 1, 0 0 1)) )')) ||
'</Shape>
</Transform>
</Scene>
</X3D
>' As x3ddoc;
x3ddoc
--------
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE X3D PUBLIC "ISO//Web3D//DTD X3D 3.0//EN" "http://www.web3d.org/specifications/x3d-3.0.dtd">
<X3D>
<Scene>
<Transform>
<Shape>
<Appearance>
<Material emissiveColor='0 0 1'/>
</Appearance>
<IndexedFaceSet coordIndex='0 1 2 3 -1 4 5 6 7 -1 8 9 10 11 -1 12 13 14 15 -1 16 17 18 19 -1 20 21 22 23'>
<Coordinate point='0 0 0 0 0 1 0 1 1 0 1 0 0 0 0 0 1 0 1 1 0 1 0 0 0 0 0 1 0 0 1 0 1 0 0 1 1 1 0 1 1 1 1 0 1 1 0 0 0 1 0 0 1 1 1 1 1 1 1 0 0 0 1 1 0 1 1 1 1 0 1 1' />
</IndexedFaceSet>
</Shape>
</Transform>
</Scene>
</X3D>
PostGIS buildings.
Kopiera och klistra in resultatet av den här frågan i x3d scene viewer och klicka på Show
SELECT string_agg('<Shape
>' || ST_AsX3D(CG_Extrude(geom, 0,0, i*0.5)) ||
'<Appearance>
<Material diffuseColor="' || (0.01*i)::text || ' 0.8 0.2" specularColor="' || (0.05*i)::text || ' 0 0.5"/>
</Appearance>
</Shape
>', '')
FROM ST_Subdivide(ST_Letters('PostGIS'),20) WITH ORDINALITY AS f(geom,i);
The following preview shows the extruded geometry generated from a simplified version of the same source lettering. It is a geometry preview, not X3D markup; use the preceding ST_AsX3D query output in an X3D viewer to inspect the native X3D scene.
SELECT
CG_Extrude(
ST_SimplifyPreserveTopology(ST_Letters('PostGIS'), 2),
0, 0, 10
) AS buildings;GEOMETRYCOLLECTION Z (POLYHEDRALSURFACE Z (((42.6 39.2 0,36.3 24.5 0,17 20.3 0,17.9 0 0,0 0 0,0 73.8 0,27.3 73.6 0,36.3 70 0,41.8 61.6 0,42.6 39.2 0),(26.5 55.7 0,17 58.8 0,17 35.3 0,25.6 36.2 0,26.5 55.7 0)),((42.6 39.2 10,41.8 61.6 10,36.3 70 10,27.3 73.6 10,0 73.8 10,0 0 10,17.9 0 10,17 20.3 10,36.3 24.5 10,42.6 39.2 10),(26.5 55.7 10,25.6 36.2 10,17 35.3 10,17 58.8 10,26.5 55.7 10)),((42.6 39.2 0,42.6 39.2 10,36.3 24.5 10,36.3 24.5 0,42.6 39.2 0)),((36.3 24.5 0,36.3 24.5 10,17 20.3 10,17 20.3 0,36.3 24.5 0)),((17 20.3 0,17 20.3 10,17.9 0 10,17.9 0 0,17 20.3 0)),((17.9 0 0,17.9 0 10,0 0 10,0 0 0,17.9 0 0)),((0 0 0,0 0 10,0 73.8 10,0 73.8 0,0 0 0)),((0 73.8 0,0 73.8 10,27.3 73.6 10,27.3 73.6 0,0 73.8 0)),((27.3 73.6 0,27.3 73.6 10,36.3 70 10,36.3 70 0,27.3 73.6 0)),((36.3 70 0,36.3 70 10,41.8 61.6 10,41.8 61.6 0,36.3 70 0)),((41.8 61.6 0,41.8 61.6 10,42.6 39.2 10,42.6 39.2 0,41.8 61.6 0)),((26.5 55.7 0,26.5 55.7 10,17 58.8 10,17 58.8 0,26.5 55.7 0)),((17 58.8 0,17 58.8 10,17 35.3 10,17 35.3 0,17 58.8 0)),((17 35.3 0,17 35.3 10,25.6 36.2 10,25.6 36.2 0,17 35.3 0)),((25.6 36.2 0,25.6 36.2 10,26.5 55.7 10,26.5 55.7 0,25.6 36.2 0))),POLYHEDRALSURFACE Z (((69.01 58 0,84.51 52.5 0,89.71 39.9 0,87.81 9.7 0,81.71 2.9 0,71.31 -0.5 0,54.91 3.9 0,48.31 17.8 0,50.61 48.7 0,58.01 55.6 0,69.01 58 0),(73.91 38.9 0,69.11 42.6 0,64.21 38.9 0,64.21 18.9 0,68.91 15.2 0,73.91 18.9 0,73.91 38.9 0)),((69.01 58 10,58.01 55.6 10,50.61 48.7 10,48.31 17.8 10,54.91 3.9 10,71.31 -0.5 10,81.71 2.9 10,87.81 9.7 10,89.71 39.9 10,84.51 52.5 10,69.01 58 10),(73.91 38.9 10,73.91 18.9 10,68.91 15.2 10,64.21 18.9 10,64.21 38.9 10,69.11 42.6 10,73.91 38.9 10)),((69.01 58 0,69.01 58 10,84.51 52.5 10,84.51 52.5 0,69.01 58 0)),((84.51 52.5 0,84.51 52.5 10,89.71 39.9 10,89.71 39.9 0,84.51 52.5 0)),((89.71 39.9 0,89.71 39.9 10,87.81 9.7 10,87.81 9.7 0,89.71 39.9 0)),((87.81 9.7 0,87.81 9.7 10,81.71 2.9 10,81.71 2.9 0,87.81 9.7 0)),((81.71 2.9 0,81.71 2.9 10,71.31 -0.5 10,71.31 -0.5 0,81.71 2.9 0)),((71.31 -0.5 0,71.31 -0.5 10,54.91 3.9 10,54.91 3.9 0,71.31 -0.5 0)),((54.91 3.9 0,54.91 3.9 10,48.31 17.8 10,48.31 17.8 0,54.91 3.9 0)),((48.31 17.8 0,48.31 17.8 10,50.61 48.7 10,50.61 48.7 0,48.31 17.8 0)),((50.61 48.7 0,50.61 48.7 10,58.01 55.6 10,58.01 55.6 0,50.61 48.7 0)),((58.01 55.6 0,58.01 55.6 10,69.01 58 10,69.01 58 0,58.01 55.6 0)),((73.91 38.9 0,73.91 38.9 10,69.11 42.6 10,69.11 42.6 0,73.91 38.9 0)),((69.11 42.6 0,69.11 42.6 10,64.21 38.9 10,64.21 38.9 0,69.11 42.6 0)),((64.21 38.9 0,64.21 38.9 10,64.21 18.9 10,64.21 18.9 0,64.21 38.9 0)),((64.21 18.9 0,64.21 18.9 10,68.91 15.2 10,68.91 15.2 0,64.21 18.9 0)),((68.91 15.2 0,68.91 15.2 10,73.91 18.9 10,73.91 18.9 0,68.91 15.2 0)),((73.91 18.9 0,73.91 18.9 10,73.91 38.9 10,73.91 38.9 0,73.91 18.9 0))),POLYHEDRALSURFACE Z (((111.02 37.6 0,123.92 31.1 0,130.72 20.8 0,126.82 5.3 0,116.02 -0.3 0,94.02 3.7 0,98.82 18.9 0,112.52 15.3 0,115.02 17.6 0,98.72 29.6 0,96.12 45.4 0,100.52 53 0,107.32 57.1 0,128.92 54.7 0,122.72 39.9 0,112.02 42.1 0,111.02 37.6 0)),((111.02 37.6 10,112.02 42.1 10,122.72 39.9 10,128.92 54.7 10,107.32 57.1 10,100.52 53 10,96.12 45.4 10,98.72 29.6 10,115.02 17.6 10,112.52 15.3 10,98.82 18.9 10,94.02 3.7 10,116.02 -0.3 10,126.82 5.3 10,130.72 20.8 10,123.92 31.1 10,111.02 37.6 10)),((111.02 37.6 0,111.02 37.6 10,123.92 31.1 10,123.92 31.1 0,111.02 37.6 0)),((123.92 31.1 0,123.92 31.1 10,130.72 20.8 10,130.72 20.8 0,123.92 31.1 0)),((130.72 20.8 0,130.72 20.8 10,126.82 5.3 10,126.82 5.3 0,130.72 20.8 0)),((126.82 5.3 0,126.82 5.3 10,116.02 -0.3 10,116.02 -0.3 0,126.82 5.3 0)),((116.02 -0.3 0,116.02 -0.3 10,94.02 3.7 10,94.02 3.7 0,116.02 -0.3 0)),((94.02 3.7 0,94.02 3.7 10,98.82 18.9 10,98.82 18.9 0,94.02 3.7 0)),((98.82 18.9 0,98.82 18.9 10,112.52 15.3 10,112.52 15.3 0,98.82 18.9 0)),((112.52 15.3 0,112.52 15.3 10,115.02 17.6 10,115.02 17.6 0,112.52 15.3 0)),((115.02 17.6 0,115.02 17.6 10,98.72 29.6 10,98.72 29.6 0,115.02 17.6 0)),((98.72 29.6 0,98.72 29.6 10,96.12 45.4 10,96.12 45.4 0,98.72 29.6 0)),((96.12 45.4 0,96.12 45.4 10,100.52 53 10,100.52 53 0,96.12 45.4 0)),((100.52 53 0,100.52 53 10,107.32 57.1 10,107.32 57.1 0,100.52 53 0)),((107.32 57.1 0,107.32 57.1 10,128.92 54.7 10,128.92 54.7 0,107.32 57.1 0)),((128.92 54.7 0,128.92 54.7 10,122.72 39.9 10,122.72 39.9 0,128.92 54.7 0)),((122.72 39.9 0,122.72 39.9 10,112.02 42.1 10,112.02 42.1 0,122.72 39.9 0)),((112.02 42.1 0,112.02 42.1 10,111.02 37.6 10,111.02 37.6 0,112.02 42.1 0))),POLYHEDRALSURFACE Z (((156.82 17.7 0,167.02 16 0,167.02 -0.9 0,149.22 2 0,141.42 11.3 0,141.12 42.7 0,134.62 41.8 0,134.62 58.9 0,141.12 57.9 0,140.02 75.4 0,157.92 75.4 0,156.82 57.9 0,166.02 58.9 0,166.02 41.8 0,156.82 42.7 0,156.82 17.7 0)),((156.82 17.7 10,156.82 42.7 10,166.02 41.8 10,166.02 58.9 10,156.82 57.9 10,157.92 75.4 10,140.02 75.4 10,141.12 57.9 10,134.62 58.9 10,134.62 41.8 10,141.12 42.7 10,141.42 11.3 10,149.22 2 10,167.02 -0.9 10,167.02 16 10,156.82 17.7 10)),((156.82 17.7 0,156.82 17.7 10,167.02 16 10,167.02 16 0,156.82 17.7 0)),((167.02 16 0,167.02 16 10,167.02 -0.9 10,167.02 -0.9 0,167.02 16 0)),((167.02 -0.9 0,167.02 -0.9 10,149.22 2 10,149.22 2 0,167.02 -0.9 0)),((149.22 2 0,149.22 2 10,141.42 11.3 10,141.42 11.3 0,149.22 2 0)),((141.42 11.3 0,141.42 11.3 10,141.12 42.7 10,141.12 42.7 0,141.42 11.3 0)),((141.12 42.7 0,141.12 42.7 10,134.62 41.8 10,134.62 41.8 0,141.12 42.7 0)),((134.62 41.8 0,134.62 41.8 10,134.62 58.9 10,134.62 58.9 0,134.62 41.8 0)),((134.62 58.9 0,134.62 58.9 10,141.12 57.9 10,141.12 57.9 0,134.62 58.9 0)),((141.12 57.9 0,141.12 57.9 10,140.02 75.4 10,140.02 75.4 0,141.12 57.9 0)),((140.02 75.4 0,140.02 75.4 10,157.92 75.4 10,157.92 75.4 0,140.02 75.4 0)),((157.92 75.4 0,157.92 75.4 10,156.82 57.9 10,156.82 57.9 0,157.92 75.4 0)),((156.82 57.9 0,156.82 57.9 10,166.02 58.9 10,166.02 58.9 0,156.82 57.9 0)),((166.02 58.9 0,166.02 58.9 10,166.02 41.8 10,166.02 41.8 0,166.02 58.9 0)),((166.02 41.8 0,166.02 41.8 10,156.82 42.7 10,156.82 42.7 0,166.02 41.8 0)),((156.82 42.7 0,156.82 42.7 10,156.82 17.7 10,156.82 17.7 0,156.82 42.7 0))),POLYHEDRALSURFACE Z (((213.81 13.2 0,208.11 4.2 0,198.51 -0.3 0,184.21 0.9 0,174.91 8.8 0,172.61 57.4 0,175.21 66.1 0,180.91 71.6 0,209.81 74 0,209.81 58.4 0,189.11 56.8 0,188.61 18.7 0,193.81 14.8 0,199.11 16.5 0,199.11 32.2 0,193.41 32.2 0,193.41 46.4 0,213.81 46.4 0,213.81 13.2 0)),((213.81 13.2 10,213.81 46.4 10,193.41 46.4 10,193.41 32.2 10,199.11 32.2 10,199.11 16.5 10,193.81 14.8 10,188.61 18.7 10,189.11 56.8 10,209.81 58.4 10,209.81 74 10,180.91 71.6 10,175.21 66.1 10,172.61 57.4 10,174.91 8.8 10,184.21 0.9 10,198.51 -0.3 10,208.11 4.2 10,213.81 13.2 10)),((213.81 13.2 0,213.81 13.2 10,208.11 4.2 10,208.11 4.2 0,213.81 13.2 0)),((208.11 4.2 0,208.11 4.2 10,198.51 -0.3 10,198.51 -0.3 0,208.11 4.2 0)),((198.51 -0.3 0,198.51 -0.3 10,184.21 0.9 10,184.21 0.9 0,198.51 -0.3 0)),((184.21 0.9 0,184.21 0.9 10,174.91 8.8 10,174.91 8.8 0,184.21 0.9 0)),((174.91 8.8 0,174.91 8.8 10,172.61 57.4 10,172.61 57.4 0,174.91 8.8 0)),((172.61 57.4 0,172.61 57.4 10,175.21 66.1 10,175.21 66.1 0,172.61 57.4 0)),((175.21 66.1 0,175.21 66.1 10,180.91 71.6 10,180.91 71.6 0,175.21 66.1 0)),((180.91 71.6 0,180.91 71.6 10,209.81 74 10,209.81 74 0,180.91 71.6 0)),((209.81 74 0,209.81 74 10,209.81 58.4 10,209.81 58.4 0,209.81 74 0)),((209.81 58.4 0,209.81 58.4 10,189.11 56.8 10,189.11 56.8 0,209.81 58.4 0)),((189.11 56.8 0,189.11 56.8 10,188.61 18.7 10,188.61 18.7 0,189.11 56.8 0)),((188.61 18.7 0,188.61 18.7 10,193.81 14.8 10,193.81 14.8 0,188.61 18.7 0)),((193.81 14.8 0,193.81 14.8 10,199.11 16.5 10,199.11 16.5 0,193.81 14.8 0)),((199.11 16.5 0,199.11 16.5 10,199.11 32.2 10,199.11 32.2 0,199.11 16.5 0)),((199.11 32.2 0,199.11 32.2 10,193.41 32.2 10,193.41 32.2 0,199.11 32.2 0)),((193.41 32.2 0,193.41 32.2 10,193.41 46.4 10,193.41 46.4 0,193.41 32.2 0)),((193.41 46.4 0,193.41 46.4 10,213.81 46.4 10,213.81 46.4 0,193.41 46.4 0)),((213.81 46.4 0,213.81 46.4 10,213.81 13.2 10,213.81 13.2 0,213.81 46.4 0))),POLYHEDRALSURFACE Z (((235.82 72.9 0,236.82 0 0,218.52 0 0,218.52 73.8 0,235.82 72.9 0)),((235.82 72.9 10,218.52 73.8 10,218.52 0 10,236.82 0 10,235.82 72.9 10)),((235.82 72.9 0,235.82 72.9 10,236.82 0 10,236.82 0 0,235.82 72.9 0)),((236.82 0 0,236.82 0 10,218.52 0 10,218.52 0 0,236.82 0 0)),((218.52 0 0,218.52 0 10,218.52 73.8 10,218.52 73.8 0,218.52 0 0)),((218.52 73.8 0,218.52 73.8 10,235.82 72.9 10,235.82 72.9 0,218.52 73.8 0))),POLYHEDRALSURFACE Z (((258.33 49.5 0,279.93 34.6 0,283.43 25.9 0,282.53 15.4 0,277.93 6.8 0,270.73 1.6 0,252.33 0.5 0,241.53 4.9 0,246.43 20.6 0,260.73 16.4 0,266.23 18.7 0,267.43 23.2 0,245.63 39.4 0,242.03 48.6 0,242.83 59.6 0,247.53 67.3 0,257.53 73.2 0,280.43 70.8 0,275.23 56.4 0,264.53 58.3 0,258.73 55.1 0,258.33 49.5 0)),((258.33 49.5 10,258.73 55.1 10,264.53 58.3 10,275.23 56.4 10,280.43 70.8 10,257.53 73.2 10,247.53 67.3 10,242.83 59.6 10,242.03 48.6 10,245.63 39.4 10,267.43 23.2 10,266.23 18.7 10,260.73 16.4 10,246.43 20.6 10,241.53 4.9 10,252.33 0.5 10,270.73 1.6 10,277.93 6.8 10,282.53 15.4 10,283.43 25.9 10,279.93 34.6 10,258.33 49.5 10)),((258.33 49.5 0,258.33 49.5 10,279.93 34.6 10,279.93 34.6 0,258.33 49.5 0)),((279.93 34.6 0,279.93 34.6 10,283.43 25.9 10,283.43 25.9 0,279.93 34.6 0)),((283.43 25.9 0,283.43 25.9 10,282.53 15.4 10,282.53 15.4 0,283.43 25.9 0)),((282.53 15.4 0,282.53 15.4 10,277.93 6.8 10,277.93 6.8 0,282.53 15.4 0)),((277.93 6.8 0,277.93 6.8 10,270.73 1.6 10,270.73 1.6 0,277.93 6.8 0)),((270.73 1.6 0,270.73 1.6 10,252.33 0.5 10,252.33 0.5 0,270.73 1.6 0)),((252.33 0.5 0,252.33 0.5 10,241.53 4.9 10,241.53 4.9 0,252.33 0.5 0)),((241.53 4.9 0,241.53 4.9 10,246.43 20.6 10,246.43 20.6 0,241.53 4.9 0)),((246.43 20.6 0,246.43 20.6 10,260.73 16.4 10,260.73 16.4 0,246.43 20.6 0)),((260.73 16.4 0,260.73 16.4 10,266.23 18.7 10,266.23 18.7 0,260.73 16.4 0)),((266.23 18.7 0,266.23 18.7 10,267.43 23.2 10,267.43 23.2 0,266.23 18.7 0)),((267.43 23.2 0,267.43 23.2 10,245.63 39.4 10,245.63 39.4 0,267.43 23.2 0)),((245.63 39.4 0,245.63 39.4 10,242.03 48.6 10,242.03 48.6 0,245.63 39.4 0)),((242.03 48.6 0,242.03 48.6 10,242.83 59.6 10,242.83 59.6 0,242.03 48.6 0)),((242.83 59.6 0,242.83 59.6 10,247.53 67.3 10,247.53 67.3 0,242.83 59.6 0)),((247.53 67.3 0,247.53 67.3 10,257.53 73.2 10,257.53 73.2 0,247.53 67.3 0)),((257.53 73.2 0,257.53 73.2 10,280.43 70.8 10,280.43 70.8 0,257.53 73.2 0)),((280.43 70.8 0,280.43 70.8 10,275.23 56.4 10,275.23 56.4 0,280.43 70.8 0)),((275.23 56.4 0,275.23 56.4 10,264.53 58.3 10,264.53 58.3 0,275.23 56.4 0)),((264.53 58.3 0,264.53 58.3 10,258.73 55.1 10,258.73 55.1 0,264.53 58.3 0)),((258.73 55.1 0,258.73 55.1 10,258.33 49.5 10,258.33 49.5 0,258.73 55.1 0))))
An Octagon elevated 3 Units and decimal precision of 6.
SELECT ST_AsX3D(ST_Translate(ST_Force3D(ST_Buffer(ST_Point(10,10),5, 'quad_segs=2')), 0,0,
3),
6) As x3dfrag;
x3dfrag -------- <IndexedFaceSet convex='false' coordIndex='0 1 2 3 4 5 6 7' ><Coordinate point='15 10 3 13.535534 6.464466 3 10 5 3 6.464466 6.464466 3 5 10 3 6.464466 13.535534 3 10 15 3 13.535534 13.535534 3 ' /></IndexedFaceSet>
TIN.
SELECT ST_AsX3D(ST_GeomFromEWKT('TIN (((
0 0 0,
0 0 1,
0 1 0,
0 0 0
)), ((
0 0 0,
0 1 0,
1 1 0,
0 0 0
))
)')) As x3dfrag;
x3dfrag
--------
<IndexedTriangleSet index='0 1 2 3 4 5'
><Coordinate point='0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 1 1 0'/></IndexedTriangleSet>
Closed multilinestring (the boundary of a polygon with holes).
SELECT ST_AsX3D(ST_GeomFromEWKT('MULTILINESTRING((20 0 10,16 -12 10,0 -16 10,-12 -12 10,-20 0 10,-12 16 10,0 24 10,16 16 10,20 0 10),
(12 0 10,8 8 10,0 12 10,-8 8 10,-8 0 10,-8 -4 10,0 -8 10,8 -4 10,12 0 10))')
) As x3dfrag;
x3dfrag
--------
<IndexedLineSet coordIndex='0 1 2 3 4 5 6 7 0 -1 8 9 10 11 12 13 14 15 8'>
<Coordinate point='20 0 10 16 -12 10 0 -16 10 -12 -12 10 -20 0 10 -12 16 10 0 24 10 16 16 10 12 0 10 8 8 10 0 12 10 -8 8 10 -8 0 10 -8 -4 10 0 -8 10 8 -4 10 ' />
</IndexedLineSet>
ST_GeoHash — Returnerar en GeoHash-representation av geometrin.
text ST_GeoHash(geometry geom, integer maxchars=full_precision_of_point);
Beräknar en GeoHash-representation av en geometri. En GeoHash kodar en geografisk punkt till en textform som är sorterbar och sökbar baserat på prefix. En kortare GeoHash är en mindre exakt representation av en punkt. Den kan betraktas som en låda som innehåller punkten.
Icke-punktgeometriska värden med en utsträckning som inte är noll kan också mappas till GeoHash-koder. Kodens precision beror på geometrins geografiska utbredning.
Om maxchars inte anges är den returnerade GeoHash-koden för den minsta cell som innehåller indatageometrin. Punkter returnerar en GeoHash med 20 teckens precision (ungefär tillräckligt för att rymma indata med full dubbel precision). Andra geometriska typer kan returnera en GeoHash med lägre precision, beroende på geometrins omfattning. Större geometrier representeras med mindre precision, mindre med mer precision. Den ruta som bestäms av GeoHash-koden innehåller alltid indatafunktionen.
Om maxchars anges har den returnerade GeoHash-koden högst så många tecken. Den mappas till en (eventuellt) lägre precisionsrepresentation av indatageometrin. För icke-punkter är beräkningens startpunkt centrum för geometrins avgränsande box.
Tillgänglighet: 1.4.0
![]() | |
ST_GeoHash kräver att indatageometrin är i geografiska koordinater (lon/lat). |
Denna metod stöder cirkulära strängar och kurvor.
SELECT ST_GeoHash(ST_Point(-126, 48));
c0w3hf1s70w3hf1s70w3
SELECT ST_GeoHash(ST_Point(-126, 48), 5);
c0w3h
This example shows that the GeoHash for a line containing a point is a prefix of the point code.
SELECT ST_GeoHash('LINESTRING(-126 48,-126.1 48.1)'::geometry);c0w3
These entries document the spatial operators defined by PostGIS. Operators complement the function catalogue by supplying concise symbolic predicates for bounding-box interactions and spatial relationships. Their semantics follow the same geometric rules as the corresponding functions but are optimised for use in SQL expressions and index-supported filtering.
TRUE om A:s 2D-begränsningsbox skär B:s 2D-begränsningsbox.TRUE om en geometris (cachelagrade) 2D-begränsningsbox skär en 2D-begränsningsbox med flytande precision (BOX2DF).TRUE om en 2D-gränsbox med flytande precision (BOX2DF) skär en geometris (cachelagrade) 2D-gränsbox.TRUE om två 2D-begränsningsboxar med flytande precision (BOX2DF) skär varandra.TRUE om A:s n-D-gränsbox skär B:s n-D-gränsbox.TRUE om en geometris (cachade) n-D-begränsningsbox skär en n-D-begränsningsbox med flytande precision (GIDX).TRUE om en n-D avgränsningsbox med flytande precision (GIDX) skär en geometris (cachelagrade) n-D avgränsningsbox.TRUE om två gränsboxar (GIDX) med n-D floatprecision skär varandra.TRUE om A:s avgränsande box överlappar eller ligger till vänster om B:s.TRUE om A:s avgränsande box överlappar eller ligger under B:s.TRUE om A:s avgränsande box överlappar eller är till höger om B:s.TRUE om A:s avgränsande box ligger strikt till vänster om B:s.TRUE om A:s avgränsande box är strikt under B:s.TRUE om koordinaterna och koordinatordningen för geometri/geografi A är samma som koordinaterna och koordinatordningen för geometri/geografi B.TRUE om A:s avgränsande box ligger strikt till höger om B:s.TRUE om A:s avgränsande box ingår i B:s.TRUE om en geometris 2D-begränsningsbox ingår i en 2D-begränsningsbox med flytande precision (BOX2DF).TRUE om en 2D-gränsbox med flytande precision (BOX2DF) ingår i en geometris 2D-gränsbox.TRUE om en avgränsande 2D-box med flytande precision (BOX2DF) ingår i en annan avgränsande 2D-box med flytande precision.TRUE om A:s avgränsande box överlappar eller ligger ovanför B:s.TRUE om A:s avgränsande box är strikt över B:s.TRUE om A:s avgränsande box innehåller B:s.TRUE om en geometris 2D-bindningsbox innehåller en 2D-bindningsbox med floatprecision (GIDX).TRUE om en 2D-gränsbox med flytande precision (BOX2DF) innehåller en geometris 2D-bondingbox.TRUE om en avgränsande 2D-box med flytande precision (BOX2DF) innehåller en annan avgränsande 2D-box med flytande precision (BOX2DF).TRUE om A:s avgränsande box är densamma som B:s.&& — Returnerar TRUE om A:s 2D-begränsningsbox skär B:s 2D-begränsningsbox.
boolean &&( geometry A , geometry B );
boolean &&( geography A , geography B );
Operatorn && returnerar TRUE om den 2D-begränsande boxen för geometri A skär den 2D-begränsande boxen för geometri B.
![]() | |
Detta operand kommer att använda alla index som kan finnas tillgängliga på geometrierna. |
Förbättrad: 2.0.0 stöd för polyhedrala ytor infördes.
Tillgänglighet: 1.5.0 stöd för geografi infördes.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
SELECT tbl1.column1, tbl2.column1, tbl1.column2 && tbl2.column2 AS overlaps
FROM ( VALUES
(1, 'LINESTRING(0 0, 3 3)'::geometry),
(2, 'LINESTRING(0 1, 0 5)'::geometry)) AS tbl1,
( VALUES
(3, 'LINESTRING(1 2, 4 6)'::geometry)) AS tbl2;
column1 | column1 | overlaps
---------+---------+----------
1 | 3 | t
2 | 3 | f
(2 rows)&&(geometry,box2df) — Returnerar TRUE om en geometris (cachelagrade) 2D-begränsningsbox skär en 2D-begränsningsbox med flytande precision (BOX2DF).
boolean &&( geometry A , box2df B );
Operatorn && returnerar TRUE om den cachade 2D-begränsningsrutan för geometri A skär 2D-begränsningsrutan B, med float-precision. Detta innebär att om B är en (dubbel precision) box2d, kommer den att konverteras internt till en 2D-begränsningsbox med flytande precision (BOX2DF)
![]() | |
Denna operand är avsedd att användas internt av BRIN-index, mer än av användare. |
Availability: 2.3.0 support for Block Range INdexes (BRIN) was introduced.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
SELECT ST_Point(1,1) && ST_MakeBox2D(ST_Point(0,0), ST_Point(2,2)) AS overlaps;
overlaps ---------- t (1 row)
&&(box2df,geometry) — Returnerar TRUE om en 2D-gränsbox med flytande precision (BOX2DF) skär en geometris (cachelagrade) 2D-gränsbox.
boolean &&( box2df A , geometry B );
Operatorn && returnerar TRUE om 2D-begränsningsrutan A skär den cachade 2D-begränsningsrutan för geometri B, med float-precision. Detta innebär att om A är en (dubbel precision) box2d, kommer den att konverteras internt till en 2D-gränsbox med flytande precision (BOX2DF)
![]() | |
Denna operand är avsedd att användas internt av BRIN-index, mer än av användare. |
Availability: 2.3.0 support for Block Range INdexes (BRIN) was introduced.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
SELECT ST_MakeBox2D(ST_Point(0,0), ST_Point(2,2)) && ST_Point(1,1) AS overlaps;
overlaps ---------- t (1 row)
&&(box2df,box2df) — Returnerar TRUE om två 2D-begränsningsboxar med flytande precision (BOX2DF) skär varandra.
boolean &&( box2df A , box2df B );
Operatorn && returnerar TRUE om två 2D-begränsningsrutor A och B skär varandra, med float-precision. Detta innebär att om A (eller B) är en box2d (dubbel precision), konverteras den internt till en 2D-gränsbox med flytande precision (BOX2DF)
![]() | |
Denna operator är avsedd att användas internt av BRIN-index, mer än av användare. |
Availability: 2.3.0 support for Block Range INdexes (BRIN) was introduced.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
SELECT ST_MakeBox2D(ST_Point(0,0), ST_Point(2,2)) && ST_MakeBox2D(ST_Point(1,1), ST_Point(3,3)) AS overlaps;
overlaps ---------- t (1 row)
&&& — Returnerar TRUE om A:s n-D-gränsbox skär B:s n-D-gränsbox.
boolean &&&( geometry A , geometry B );
Operatorn &&& returnerar TRUE om n-D-gränsboxen för geometri A skär n-D-gränsboxen för geometri B.
![]() | |
Detta operand kommer att använda alla index som kan finnas tillgängliga på geometrierna. |
Tillgänglighet: 2.0.0
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
Denna funktion stöder 3d och kommer inte att tappa z-index.
3D LineStrings.
SELECT tbl1.column1, tbl2.column1, tbl1.column2 &&& tbl2.column2 AS overlaps_3d,
tbl1.column2 && tbl2.column2 AS overlaps_2d
FROM ( VALUES
(1, 'LINESTRING Z(0 0 1, 3 3 2)'::geometry),
(2, 'LINESTRING Z(1 2 0, 0 5 -1)'::geometry)) AS tbl1,
( VALUES
(3, 'LINESTRING Z(1 2 1, 4 6 1)'::geometry)) AS tbl2;
column1 | column1 | overlaps_3d | overlaps_2d
---------+---------+-------------+-------------
1 | 3 | t | t
2 | 3 | f | t
3M LineStrings.
SELECT tbl1.column1, tbl2.column1, tbl1.column2 &&& tbl2.column2 AS overlaps_3zm,
tbl1.column2 && tbl2.column2 AS overlaps_2d
FROM ( VALUES
(1, 'LINESTRING M(0 0 1, 3 3 2)'::geometry),
(2, 'LINESTRING M(1 2 0, 0 5 -1)'::geometry)) AS tbl1,
( VALUES
(3, 'LINESTRING M(1 2 1, 4 6 1)'::geometry)) AS tbl2;
column1 | column1 | overlaps_3zm | overlaps_2d
---------+---------+-------------+-------------
1 | 3 | t | t
2 | 3 | f | t
&&&(geometry,gidx) — Returnerar TRUE om en geometris (cachade) n-D-begränsningsbox skär en n-D-begränsningsbox med flytande precision (GIDX).
boolean &&&( geometry A , gidx B );
Operatorn &&& returnerar TRUE om den cachade n-D-begränsningsrutan för geometri A skär n-D-begränsningsrutan B, med float-precision. Detta innebär att om B är en (dubbel precision) box3d, kommer den att konverteras internt till en 3D-begränsningsbox med flytande precision (GIDX)
![]() | |
Denna operator är avsedd att användas internt av BRIN-index, mer än av användare. |
Availability: 2.3.0 support for Block Range INdexes (BRIN) was introduced.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
Denna funktion stöder 3d och kommer inte att tappa z-index.
SELECT ST_MakePoint(1,1,1) &&& ST_3DMakeBox(ST_MakePoint(0,0,0), ST_MakePoint(2,2,2)) AS overlaps;
overlaps ---------- t (1 row)
&&&(gidx,geometry) — Returnerar TRUE om en n-D avgränsningsbox med flytande precision (GIDX) skär en geometris (cachelagrade) n-D avgränsningsbox.
boolean &&&( gidx A , geometry B );
Operatorn &&& returnerar TRUE om n-D-begränsningsrutan A skär den cachade n-D-begränsningsrutan för geometri B, med float-precision. Detta innebär att om A är en box3d (dubbel precision) kommer den att konverteras internt till en 3D-gränsbox med flytande precision (GIDX)
![]() | |
Denna operator är avsedd att användas internt av BRIN-index, mer än av användare. |
Availability: 2.3.0 support for Block Range INdexes (BRIN) was introduced.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
Denna funktion stöder 3d och kommer inte att tappa z-index.
SELECT ST_3DMakeBox(ST_MakePoint(0,0,0), ST_MakePoint(2,2,2)) &&& ST_MakePoint(1,1,1) AS overlaps;
overlaps ---------- t (1 row)
&&&(gidx,gidx) — Returnerar TRUE om två gränsboxar (GIDX) med n-D floatprecision skär varandra.
boolean &&&( gidx A , gidx B );
Operatorn &&& returnerar TRUE om två n-D-begränsningsrutor A och B skär varandra, med float-precision. Detta innebär att om A (eller B) är en (dubbel precision) box3d, konverteras den internt till en 3D-gränsbox med flytande precision (GIDX)
![]() | |
Denna operator är avsedd att användas internt av BRIN-index, mer än av användare. |
Availability: 2.3.0 support for Block Range INdexes (BRIN) was introduced.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
Denna funktion stöder 3d och kommer inte att tappa z-index.
SELECT ST_3DMakeBox(ST_MakePoint(0,0,0), ST_MakePoint(2,2,2)) &&& ST_3DMakeBox(ST_MakePoint(1,1,1), ST_MakePoint(3,3,3)) AS overlaps;
overlaps ---------- t (1 row)
&< — Returnerar TRUE om A:s avgränsande box överlappar eller ligger till vänster om B:s.
boolean &<( geometry A , geometry B );
Operatorn &< returnerar TRUE om geometri A:s avgränsande box överlappar eller är till vänster om geometri B:s avgränsande box, eller mer exakt, överlappar eller INTE är till höger om geometri B:s avgränsande box.
![]() | |
Detta operand kommer att använda alla index som kan finnas tillgängliga på geometrierna. |
SELECT tbl1.column1, tbl2.column1, tbl1.column2 &< tbl2.column2 AS overleft
FROM
( VALUES
(1, 'LINESTRING(1 2, 4 6)'::geometry)) AS tbl1,
( VALUES
(2, 'LINESTRING(0 0, 3 3)'::geometry),
(3, 'LINESTRING(0 1, 0 5)'::geometry),
(4, 'LINESTRING(6 0, 6 1)'::geometry)) AS tbl2;
column1 | column1 | overleft
---------+---------+----------
1 | 2 | f
1 | 3 | f
1 | 4 | t
(3 rows)
&<| — Returnerar TRUE om A:s avgränsande box överlappar eller ligger under B:s.
boolean &<|( geometry A , geometry B );
Operatorn &<| returnerar TRUE om begränsningsrutan för geometri A överlappar eller ligger under begränsningsrutan för geometri B, eller mer exakt, överlappar eller INTE ligger över begränsningsrutan för geometri B.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
![]() | |
Detta operand kommer att använda alla index som kan finnas tillgängliga på geometrierna. |
SELECT tbl1.column1, tbl2.column1, tbl1.column2 &<| tbl2.column2 AS overbelow
FROM
( VALUES
(1, 'LINESTRING(6 0, 6 4)'::geometry)) AS tbl1,
( VALUES
(2, 'LINESTRING(0 0, 3 3)'::geometry),
(3, 'LINESTRING(0 1, 0 5)'::geometry),
(4, 'LINESTRING(1 2, 4 6)'::geometry)) AS tbl2;
column1 | column1 | overbelow
---------+---------+-----------
1 | 2 | f
1 | 3 | t
1 | 4 | t
(3 rows)
&> — Returnerar TRUE om A:s avgränsande box överlappar eller är till höger om B:s.
boolean &>( geometry A , geometry B );
Operatorn &> returnerar TRUE om geometri A:s avgränsande box överlappar eller ligger till höger om geometri B:s avgränsande box, eller mer exakt, överlappar eller INTE ligger till vänster om geometri B:s avgränsande box.
![]() | |
Detta operand kommer att använda alla index som kan finnas tillgängliga på geometrierna. |
SELECT tbl1.column1, tbl2.column1, tbl1.column2 &
> tbl2.column2 AS overright
FROM
( VALUES
(1, 'LINESTRING(1 2,4 6)'::geometry)) AS tbl1,
( VALUES
(2, 'LINESTRING(0 0,3 3)'::geometry),
(3, 'LINESTRING(0 1,0 5)'::geometry),
(4, 'LINESTRING(6 0,6 1)'::geometry)) AS tbl2;
column1 | column1 | overright
---------+---------+-----------
1 | 2 | t
1 | 3 | t
1 | 4 | f
(3 rows)
<< — Returnerar TRUE om A:s avgränsande box ligger strikt till vänster om B:s.
boolean <<( geometry A , geometry B );
Operatorn << returnerar TRUE om geometri A:s begränsningsbox ligger strikt till vänster om geometri B:s begränsningsbox.
![]() | |
Detta operand kommer att använda alla index som kan finnas tillgängliga på geometrierna. |
SELECT tbl1.column1, tbl2.column1, tbl1.column2 << tbl2.column2 AS left
FROM
( VALUES
(1, 'LINESTRING (1 2, 1 5)'::geometry)) AS tbl1,
( VALUES
(2, 'LINESTRING (0 0, 4 3)'::geometry),
(3, 'LINESTRING (6 0, 6 5)'::geometry),
(4, 'LINESTRING (2 2, 5 6)'::geometry)) AS tbl2;
column1 | column1 | left
---------+---------+------
1 | 2 | f
1 | 3 | t
1 | 4 | t
(3 rows)
<<| — Returnerar TRUE om A:s avgränsande box är strikt under B:s.
boolean <<|( geometry A , geometry B );
Operatorn <<| returnerar TRUE om geometri A:s begränsningsbox ligger strikt under geometri B:s begränsningsbox.
![]() | |
Detta operand kommer att använda alla index som kan finnas tillgängliga på geometrierna. |
SELECT tbl1.column1, tbl2.column1, tbl1.column2 <<| tbl2.column2 AS below
FROM
( VALUES
(1, 'LINESTRING (0 0, 4 3)'::geometry)) AS tbl1,
( VALUES
(2, 'LINESTRING (1 4, 1 7)'::geometry),
(3, 'LINESTRING (6 1, 6 5)'::geometry),
(4, 'LINESTRING (2 3, 5 6)'::geometry)) AS tbl2;
column1 | column1 | below
---------+---------+-------
1 | 2 | t
1 | 3 | f
1 | 4 | f
(3 rows)
= — Returnerar TRUE om koordinaterna och koordinatordningen för geometri/geografi A är samma som koordinaterna och koordinatordningen för geometri/geografi B.
boolean =( geometry A , geometry B );
boolean =( geography A , geography B );
Operatorn = returnerar SANT om koordinaterna och koordinatordningen geometri / geografi A är desamma som koordinaterna och koordinatordningen för geometri / geografi B. PostgreSQL använder operatorerna =, < och > som definieras för geometrier för att utföra interna ordningar och jämförelse av geometrier (dvs. i en GROUP BY- eller ORDER BY-klausul).
![]() | |
Endast geometri/geografi som är exakt lika i alla avseenden, med samma koordinater, i samma ordning, betraktas som lika av denna operator. För "spatial likhet", som ignorerar saker som koordinatordning och kan upptäcka funktioner som täcker samma spatiala område med olika representationer, använd ST_OrderingEquals eller ST_Equals |
![]() | |
Detta operand kommer INTE att använda några index som kan finnas tillgängliga på geometrierna. För ett indexassisterat exakt likhetstest, kombinera = med &&. |
Ändrad: 2.4.0, i tidigare versioner var detta bounding box-likhet inte en geometrisk likhet. Om du behöver bounding box-likhet, använd ~= istället.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
SELECT 'LINESTRING(0 0,0 1,1 0)'::geometry = 'LINESTRING(1 1,0 0)'::geometry;
?column? ---------- f (1 row)
SELECT column1
FROM ( VALUES
('LINESTRING(0 0, 1 1)'::geometry),
('LINESTRING(1 1, 0 0)'::geometry)) AS foo;st_astext --------------------- LINESTRING(0 0,1 1) LINESTRING(1 1,0 0) (2 rows)
Note: the GROUP BY uses the "=" to compare for geometry equivalency.
SELECT column1
FROM ( VALUES
('LINESTRING(0 0, 1 1)'::geometry),
('LINESTRING(1 1, 0 0)'::geometry)) AS foo
GROUP BY column1;st_astext --------------------- LINESTRING(0 0,1 1) LINESTRING(1 1,0 0) (2 rows)
In versions prior to 2.0, this used to return true.
SELECT 'POINT(1707296.37 4820536.77)'::geometry = 'POINT(1707296.27 4820536.87)'::geometry As pt_intersect;
pt_intersect -------------- f (1 row)
>> — Returnerar TRUE om A:s avgränsande box ligger strikt till höger om B:s.
boolean >>( geometry A , geometry B );
Operatorn >> returnerar TRUE om geometri A:s avgränsningsbox ligger strikt till höger om geometri B:s avgränsningsbox.
![]() | |
Detta operand kommer att använda alla index som kan finnas tillgängliga på geometrierna. |
SELECT tbl1.column1, tbl2.column1, tbl1.column2
>
> tbl2.column2 AS right
FROM
( VALUES
(1, 'LINESTRING (2 3,5 6)'::geometry)) AS tbl1,
( VALUES
(2, 'LINESTRING (1 4,1 7)'::geometry),
(3, 'LINESTRING (6 1,6 5)'::geometry),
(4, 'LINESTRING (0 0,4 3)'::geometry)) AS tbl2;
column1 | column1 | right
---------+---------+-------
1 | 2 | t
1 | 3 | f
1 | 4 | f
(3 rows)
@ — Returnerar TRUE om A:s avgränsande box ingår i B:s.
boolean @( geometry A , geometry B );
Operatorn @ returnerar TRUE om geometri A:s begränsningsbox är helt innesluten i geometri B:s begränsningsbox.
![]() | |
Detta operand kommer att använda alla index som kan finnas tillgängliga på geometrierna. |
SELECT tbl1.column1, tbl2.column1, tbl1.column2 @ tbl2.column2 AS contained
FROM
( VALUES
(1, 'LINESTRING (1 1, 3 3)'::geometry)) AS tbl1,
( VALUES
(2, 'LINESTRING (0 0, 4 4)'::geometry),
(3, 'LINESTRING (2 2, 4 4)'::geometry),
(4, 'LINESTRING (1 1, 3 3)'::geometry)) AS tbl2;
column1 | column1 | contained
---------+---------+-----------
1 | 2 | t
1 | 3 | f
1 | 4 | t
(3 rows)
@(geometry,box2df) — Returnerar TRUE om en geometris 2D-begränsningsbox ingår i en 2D-begränsningsbox med flytande precision (BOX2DF).
boolean @( geometry A , box2df B );
Operatorn @ returnerar TRUE om A-geometrins 2D-begränsningsbox ingår i 2D-begränsningsboxen B, med float-precision. Detta innebär att om B är en (dubbel precision) box2d, kommer den att konverteras internt till en 2D-gränsbox med flytande precision (BOX2DF)
![]() | |
Denna operand är avsedd att användas internt av BRIN-index, mer än av användare. |
Availability: 2.3.0 support for Block Range INdexes (BRIN) was introduced.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
SELECT ST_Buffer('POINT(2 2)'::geometry, 1) @ ST_MakeBox2D(ST_Point(0, 0), ST_Point(5, 5)) AS is_contained;t
@(box2df,geometry) — Returnerar TRUE om en 2D-gränsbox med flytande precision (BOX2DF) ingår i en geometris 2D-gränsbox.
boolean @( box2df A , geometry B );
Operatorn @ returnerar TRUE om 2D-gränsboxen A ingår i B-geometrins 2D-gränsbox, med float-precision. Detta innebär att om B är en (dubbel precision) box2d, kommer den att konverteras internt till en 2D-gränsbox med flytande precision (BOX2DF)
![]() | |
Denna operand är avsedd att användas internt av BRIN-index, mer än av användare. |
Availability: 2.3.0 support for Block Range INdexes (BRIN) was introduced.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
SELECT ST_MakeBox2D(ST_Point(2, 2), ST_Point(3, 3)) @ ST_Buffer('POINT(1 1)'::geometry, 10) AS is_contained;t
@(box2df,box2df) — Returnerar TRUE om en avgränsande 2D-box med flytande precision (BOX2DF) ingår i en annan avgränsande 2D-box med flytande precision.
boolean @( box2df A , box2df B );
Operatorn @ returnerar TRUE om 2D-begränsningsrutan A ingår i 2D-begränsningsrutan B, med float-precision. Detta innebär att om A (eller B) är en (dubbel precision) box2d, kommer den att konverteras internt till en 2D-gränsbox med flytande precision (BOX2DF)
![]() | |
Denna operand är avsedd att användas internt av BRIN-index, mer än av användare. |
Availability: 2.3.0 support for Block Range INdexes (BRIN) was introduced.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
SELECT ST_MakeBox2D(ST_Point(2, 2), ST_Point(3, 3)) @ ST_MakeBox2D(ST_Point(0, 0), ST_Point(5, 5)) AS is_contained;
t
|&> — Returnerar TRUE om A:s avgränsande box överlappar eller ligger ovanför B:s.
boolean |&>( geometry A , geometry B );
Operatorn |&> returnerar TRUE om geometri A:s begränsningsbox överlappar eller ligger ovanför geometri B:s begränsningsbox, eller mer exakt, överlappar eller INTE ligger under geometri B:s begränsningsbox.
![]() | |
Detta operand kommer att använda alla index som kan finnas tillgängliga på geometrierna. |
SELECT tbl1.column1, tbl2.column1, tbl1.column2 |&
> tbl2.column2 AS overabove
FROM
( VALUES
(1, 'LINESTRING(6 0,6 4)'::geometry)) AS tbl1,
( VALUES
(2, 'LINESTRING(0 0,3 3)'::geometry),
(3, 'LINESTRING(0 1,0 5)'::geometry),
(4, 'LINESTRING(1 2,4 6)'::geometry)) AS tbl2;
column1 | column1 | overabove
---------+---------+-----------
1 | 2 | t
1 | 3 | f
1 | 4 | f
(3 rows)
|>> — Returnerar TRUE om A:s avgränsande box är strikt över B:s.
boolean |>>( geometry A , geometry B );
Operatorn |>> returnerar TRUE om geometri A:s begränsningsbox ligger strikt ovanför geometri B:s begränsningsbox.
![]() | |
Detta operand kommer att använda alla index som kan finnas tillgängliga på geometrierna. |
SELECT tbl1.column1, tbl2.column1, tbl1.column2 |>> tbl2.column2 AS above
FROM
( VALUES
(1, 'LINESTRING (1 4,1 7)'::geometry)) AS tbl1,
( VALUES
(2, 'LINESTRING (0 0,4 2)'::geometry),
(3, 'LINESTRING (6 1,6 5)'::geometry),
(4, 'LINESTRING (2 3,5 6)'::geometry)) AS tbl2;column1 | column1 | above
---------+---------+-------
1 | 2 | t
1 | 3 | f
1 | 4 | f
(3 rows)~ — Returnerar TRUE om A:s avgränsande box innehåller B:s.
boolean ~( geometry A , geometry B );
Operatorn ~ returnerar TRUE om den avgränsande boxen för geometri A helt innehåller den avgränsande boxen för geometri B.
![]() | |
Detta operand kommer att använda alla index som kan finnas tillgängliga på geometrierna. |
SELECT tbl1.column1, tbl2.column1, tbl1.column2 ~ tbl2.column2 AS contains
FROM
( VALUES
(1, 'LINESTRING (0 0,3 3)'::geometry)) AS tbl1,
( VALUES
(2, 'LINESTRING (0 0,4 4)'::geometry),
(3, 'LINESTRING (1 1,2 2)'::geometry),
(4, 'LINESTRING (0 0,3 3)'::geometry)) AS tbl2;column1 | column1 | contains
---------+---------+----------
1 | 2 | f
1 | 3 | t
1 | 4 | t
(3 rows)~(geometry,box2df) — Returnerar TRUE om en geometris 2D-bindningsbox innehåller en 2D-bindningsbox med floatprecision (GIDX).
boolean ~( geometry A , box2df B );
Operatorn ~ returnerar TRUE om 2D-begränsningsrutan för en geometri A innehåller 2D-begränsningsrutan B, med float-precision. Detta innebär att om B är en (dubbel precision) box2d, kommer den att konverteras internt till en 2D-gränsbox med flytande precision (BOX2DF)
![]() | |
Denna operand är avsedd att användas internt av BRIN-index, mer än av användare. |
Availability: 2.3.0 support for Block Range INdexes (BRIN) was introduced.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
SELECT ST_Buffer('POINT(1 1)'::geometry, 10) ~ ST_MakeBox2D(ST_Point(0, 0), ST_Point(2, 2)) AS contains;t
~(box2df,geometry) — Returnerar TRUE om en 2D-gränsbox med flytande precision (BOX2DF) innehåller en geometris 2D-bondingbox.
boolean ~( box2df A , geometry B );
Operatorn ~ returnerar TRUE om 2D-gränsboxen A innehåller B-geometrins gränsbox, med float-precision. Detta innebär att om A är en (dubbel precision) box2d, kommer den att konverteras internt till en 2D-gränsbox med flytande precision (BOX2DF)
![]() | |
Denna operand är avsedd att användas internt av BRIN-index, mer än av användare. |
Availability: 2.3.0 support for Block Range INdexes (BRIN) was introduced.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
SELECT ST_MakeBox2D(ST_Point(0, 0), ST_Point(5, 5)) ~ ST_Buffer('POINT(2 2)'::geometry, 1) AS contains;t
~(box2df,box2df) — Returnerar TRUE om en avgränsande 2D-box med flytande precision (BOX2DF) innehåller en annan avgränsande 2D-box med flytande precision (BOX2DF).
boolean ~( box2df A , box2df B );
Operatorn ~ returnerar TRUE om 2D-begränsningsrutan A innehåller 2D-begränsningsrutan B, med float-precision. Detta innebär att om A är en (dubbel precision) box2d, kommer den att konverteras internt till en 2D-gränsbox med flytande precision (BOX2DF)
![]() | |
Denna operand är avsedd att användas internt av BRIN-index, mer än av användare. |
Availability: 2.3.0 support for Block Range INdexes (BRIN) was introduced.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
SELECT ST_MakeBox2D(ST_Point(0, 0), ST_Point(5, 5)) ~ ST_MakeBox2D(ST_Point(2, 2), ST_Point(3, 3)) AS contains;
t
~= — Returnerar TRUE om A:s avgränsande box är densamma som B:s.
boolean ~=( geometry A , geometry B );
Operatorn ~= returnerar TRUE om avgränsningsrutan för geometri/geografi A är densamma som avgränsningsrutan för geometri/geografi B.
![]() | |
Detta operand kommer att använda alla index som kan finnas tillgängliga på geometrierna. |
Tillgänglighet: 1.5.0 ändrat beteende
Denna funktion stöder polyedriska ytor.
![]() | |
Denna operator har ändrat beteende i PostGIS 1.5 från att testa för faktisk geometrisk likhet till att endast kontrollera för bounding box likhet. För att komplicera saker och ting beror det också på om du har gjort en hård eller mjuk uppgradering vilket beteende din databas har. För att ta reda på vilket beteende din databas har kan du köra frågan nedan. För att kontrollera sann jämlikhet använder du ST_OrderingEquals eller ST_Equals. |
SELECT 'LINESTRING(0 0,1 1)'::geometry ~= 'LINESTRING(0 1,1 0)'::geometry AS equality;
t
<-> — Returnerar 2D-avståndet mellan A och B.
double precision <->( geometry A , geometry B );
double precision <->( geography A , geography B );
The <-> operator returns the 2D distance between two geometries. Used in the "ORDER BY" clause provides index-assisted nearest-neighbor result sets with true KNN distance search for geometries, and distance on the sphere for geographies.
![]() | |
Denna operand använder 2D GiST-index som kan finnas tillgängliga för geometrierna. Den skiljer sig från andra operatorer som använder spatiala index genom att det spatiala indexet endast används när operatorn är i ORDER BY-satsen. |
![]() | |
Indexet börjar bara gälla om en av geometrierna är en konstant (inte i en underfråga). t.ex. 'SRID=3005;POINT(1011102 450541)'::geometry istället för a.geom |
Se PostGIS workshop: Nearest-Neighbor Searching för ett detaljerat exempel.
Enhanced: 2.2.0 -- True KNN ("K nearest neighbor") behavior for geometry and geography. Note for geography KNN is based on sphere rather than spheroid.
Changed: 2.2.0 -- Old hybrid-syntax workarounds may be slower once true KNN is available. See examples below.
Availability: 2.0.0 -- Weak KNN provides nearest neighbors based on geometry centroid distances instead of true distances. Exact results for points, inexact for all other types.
SELECT ST_Distance(geom, 'SRID=3005;POINT(1011102 450541)'::geometry) as d, edabbr, vaabbr FROM va2005 ORDER BY d limit 10;
d | edabbr | vaabbr
------------------+--------+--------
0 | ALQ | 128
5541.57712511724 | ALQ | 129A
5579.67450712005 | ALQ | 001
6083.4207708641 | ALQ | 131
7691.2205404848 | ALQ | 003
7900.75451037313 | ALQ | 122
8694.20710669982 | ALQ | 129B
9564.24289057111 | ALQ | 130
12089.665931705 | ALQ | 127
18472.5531479404 | ALQ | 002
(10 rows)Sedan KNN rå svar:
SELECT ST_Distance(geom, 'SRID=3005;POINT(1011102 450541)'::geometry) as d,edabbr, vaabbr FROM va2005 ORDER BY geom <-> 'SRID=3005;POINT(1011102 450541)'::geometry limit 10;
d | edabbr | vaabbr
------------------+--------+--------
0 | ALQ | 128
5541.57712511724 | ALQ | 129A
5579.67450712005 | ALQ | 001
6083.4207708641 | ALQ | 131
7691.2205404848 | ALQ | 003
7900.75451037313 | ALQ | 122
8694.20710669982 | ALQ | 129B
9564.24289057111 | ALQ | 130
12089.665931705 | ALQ | 127
18472.5531479404 | ALQ | 002
(10 rows)
Om du kör "EXPLAIN ANALYZE" på de två frågorna skulle du se en prestandaförbättring för den andra.
When a plan cannot produce exact distances directly, use a hybrid query to find the true nearest neighbors. First a CTE query using the index-assisted KNN, then an exact query to get correct ordering:
WITH index_query AS (
SELECT ST_Distance(geom, 'SRID=3005;POINT(1011102 450541)'::geometry) as d,edabbr, vaabbr
FROM va2005
ORDER BY geom <-> 'SRID=3005;POINT(1011102 450541)'::geometry LIMIT 100)
SELECT *
FROM index_query
ORDER BY d limit 10;
d | edabbr | vaabbr
------------------+--------+--------
0 | ALQ | 128
5541.57712511724 | ALQ | 129A
5579.67450712005 | ALQ | 001
6083.4207708641 | ALQ | 131
7691.2205404848 | ALQ | 003
7900.75451037313 | ALQ | 122
8694.20710669982 | ALQ | 129B
9564.24289057111 | ALQ | 130
12089.665931705 | ALQ | 127
18472.5531479404 | ALQ | 002
(10 rows)
|=| — Returnerar avståndet mellan A- och B-banorna vid deras närmaste inflygningspunkt.
double precision |=|( geometry A , geometry B );
The |=| operator returns the 3D distance between two trajectories (See ST_IsValidTrajectory). This is the same as ST_DistanceCPA but as an operator it can be used for doing nearest neighbor searches using an N-dimensional index.
![]() | |
Denna operand använder ND GiST-index som kan finnas tillgängliga på geometrierna. Den skiljer sig från andra operatorer som använder spatiala index genom att det spatiala indexet endast används när operatorn är i ORDER BY-satsen. |
![]() | |
Index startar bara om en av geometrierna är en konstant (inte i en underfråga/cte). t.ex. 'SRID=3005;LINESTRINGM(0 0 0,0 0 1)'::geometry istället för a.geom |
Availability: 2.2.0.
This example orders stored trajectories by their distance from a literal query trajectory.
\set qt 'ST_AddMeasure(ST_MakeLine(ST_MakePointM(-350, 300, 0), ST_MakePointM(-410, 490, 0)), 10, 20)'
SELECT track_id, dist FROM (
SELECT track_id,
ST_DistanceCPA(tr, :qt) dist
FROM trajectories
ORDER BY tr |=| :qt
LIMIT 5
) foo;track_id dist
----------+-------------------
395 | 0.576496831518066
380 | 5.06797130410151
390 | 7.72262293958322
385 | 9.8004461358071
405 | 10.9534397988433
(5 rows)<#> — Returnerar 2D-avståndet mellan A- och B-begränsningsrutorna.
double precision <#>( geometry A , geometry B );
The <#> operator returns distance between two floating point bounding boxes, possibly reading them from a spatial index. Useful for doing nearest neighbor approximate distance ordering.
![]() | |
Denna operand kommer att använda alla index som kan finnas tillgängliga på geometrierna. Den skiljer sig från andra operatorer som använder spatiala index genom att det spatiala indexet endast används när operatorn är i ORDER BY-satsen. |
![]() | |
Indexet fungerar bara om en av geometrierna är en konstant, t.ex. ORDER BY (ST_GeomFromText('POINT(1 2)') <#> geom) istället för g1.geom <#>. |
Availability: 2.0.0.
SELECT *
FROM (
SELECT b.tlid, b.mtfcc,
b.geom <#
> ST_GeomFromText('LINESTRING(746149 2948672,745954 2948576,
745787 2948499,745740 2948468,745712 2948438,
745690 2948384,745677 2948319)', 2249) As b_dist,
ST_Distance(b.geom, ST_GeomFromText('LINESTRING(746149 2948672,745954 2948576,
745787 2948499,745740 2948468,745712 2948438,
745690 2948384,745677 2948319)', 2249)) As act_dist
FROM bos_roads As b
ORDER BY b_dist, b.tlid
LIMIT 100) As foo
ORDER BY act_dist, tlid LIMIT 10;
tlid | mtfcc | b_dist | act_dist -----------+-------+------------------+------------------ 85732027 | S1400 | 0 | 0 85732029 | S1400 | 0 | 0 85732031 | S1400 | 0 | 0 85734335 | S1400 | 0 | 0 85736037 | S1400 | 0 | 0 624683742 | S1400 | 0 | 128.528874268666 85719343 | S1400 | 260.839270432962 | 260.839270432962 85741826 | S1400 | 164.759294123275 | 260.839270432962 85732032 | S1400 | 277.75 | 311.830282365264 85735592 | S1400 | 222.25 | 311.830282365264 (10 rows)
<<->> — Returnerar n-D-avståndet mellan geometrierna eller begränsningsrutorna A och B
double precision <<->>( geometry A , geometry B );
Operatorn <<->> returnerar n-D (euklidiskt) avstånd mellan mittpunkterna i de avgränsande boxarna för två geometrier. Användbar för att göra närmaste granne ungefärlig avståndsordning.
![]() | |
Denna operand använder n-D GiST-index som kan finnas tillgängliga för geometrierna. Den skiljer sig från andra operatorer som använder spatiala index genom att det spatiala indexet endast används när operatorn är i ORDER BY-satsen. |
![]() | |
Indexet börjar bara gälla om en av geometrierna är en konstant (inte i en underfråga). t.ex. 'SRID=3005;POINT(1011102 450541)'::geometry istället för a.geom |
Availability: 2.2.0.
Dessa funktioner bestämmer spatiala relationer mellan geometrier.
ST_3DIntersects — Testar om två geometrier korsar varandra spatialt i 3D - endast för punkter, linestrings, polygoner, polyedrisk yta (area)
boolean ST_3DIntersects( geometry geomA , geometry geomB );
Overlaps, Touches, Within innebär alla spatial skärning. Om någon av de ovan nämnda returnerar true, så skär geometrierna varandra även spatialt. Disjoint implicerar false för spatial intersektion.
![]() | |
Denna funktion inkluderar automatiskt en jämförelse av begränsningsrutor som använder alla spatiala index som finns tillgängliga för geometrierna. |
![]() | |
På grund av brister i den flytande robustheten korsar geometrier inte alltid varandra på det sätt som man förväntar sig efter geometrisk bearbetning. Till exempel kanske den närmaste punkten på en linestrings till en geometri inte ligger på linestringsen. För den här typen av problem, där ett avstånd på en centimeter bara ska betraktas som en skärningspunkt, använder du ST_3DDWithin. |
Ändrad: 3.0.0 SFCGAL backend borttagen, GEOS backend stöder TINs.
Tillgänglighet: 2.0.0
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
Denna metod implementerar SQL/MM-specifikationen. SQL-MM IEC 13249-3: 5.1
SELECT ST_3DIntersects(pt, line), ST_Intersects(pt, line) FROM (SELECT 'POINT(0 0 2)'::geometry As pt, 'LINESTRING (0 0 1,0 2 3)'::geometry As line) As foo;
st_3dintersects | st_intersects -----------------+--------------- f | t (1 row)
SELECT ST_3DIntersects('TIN(((0 0 0,1 0 0,0 1 0,0 0 0)))'::geometry, 'POINT(.1 .1 0)'::geometry);t
ST_Contains — Testar om varje punkt i B ligger i A, och deras interiörer har en gemensam punkt
boolean ST_Contains(geometry geomA, geometry geomB);
Returnerar TRUE om geometri A innehåller geometri B. A innehåller B om och endast om alla punkter i B ligger inuti (dvs. i det inre eller på gränsen till) A (eller motsvarande, inga punkter i B ligger i det yttre av A), och det inre av A och B har minst en punkt gemensamt.
I matematiska termer: ST_Contains(A, B) ⇔ (A ⋂ B = B) ∧ (Int(A) ⋂ Int(B) ≠ ∅)
Förhållandet contains är reflexivt: varje geometri innehåller sig själv. (I predikatet ST_ContainsProperly innehåller däremot en geometri inte sig själv på rätt sätt.) Relationen är antisymmetrisk: om ST_Contains(A,B) = true och ST_Contains(B,A) = true, måste de två geometrierna vara topologiskt lika(ST_Equals(A,B) = true).
ST_Contains är motsatsen till ST_Within. Så ST_Contains(A,B) = ST_Within(B,A)..
![]() | |
Eftersom interiörerna måste ha en gemensam punkt är en finess i definitionen att polygoner och linjer inte innehåller linjer och punkter som ligger helt inom deras gräns. För ytterligare information se Subtiliteter i OGC Covers, Contains, Within. Predikatet ST_Covers ger en mer inkluderande relation. |
![]() | |
&index_aware; För att undvika indexanvändning, använd funktionen |
Utförs av GEOS-modulen
Förbättrad: 2.3.0 Förbättring av PIP-kortslutning utökad till att stödja MultiPoints med få punkter. Tidigare versioner stödde endast punkt i polygon.
Förbättrad: 3.0.0 aktiverade stöd för GEOMETRYCOLLECTION
![]() | |
Använd inte denna funktion med ogiltiga geometrier. Du kommer att få oväntade resultat. |
OBS: detta är den "tillåtna" versionen som returnerar ett boolean, inte ett heltal.
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s2.1.1.2 // s2.1.13.3 - samma som inom(geometri B, geometri A)
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.31
ST_Contains returnerar TRUE i följande situationer:
A LineString contains a MultiPoint whose points lie in its interior or boundary.
SELECT ST_Contains(a, b) FROM (SELECT 'LINESTRING (10 190,60 80,130 120,190 10)'::geometry AS a, 'MULTIPOINT (60 80,190 10)'::geometry AS b ) AS example;
t
A Polygon contains a Point in its interior.
SELECT ST_Contains(a, b) FROM (SELECT 'POLYGON ((10 130,50 190,110 190,140 150,150 80,100 10,20 40,10 130))'::geometry AS a, 'POINT (99 130)'::geometry AS b ) AS example;
t
A Polygon contains a LineString with interior points inside the Polygon.
SELECT ST_Contains(a, b) FROM (SELECT 'POLYGON ((10 130,50 190,110 190,140 150,150 80,100 10,20 40,10 130))'::geometry AS a, 'LINESTRING (50 190,110 190,99 130)'::geometry AS b ) AS example;
t
A Polygon contains another Polygon in its interior.
SELECT ST_Contains(a, b) FROM (SELECT 'POLYGON ((10 130,50 190,110 190,140 150,150 80,100 10,20 40,10 130))'::geometry AS a, 'POLYGON ((70 40,100 50,120 80,80 110,50 90,70 40))'::geometry AS b ) AS example;
t
ST_Contains returnerar FALSE i följande situationer:
A Polygon does not contain a MultiPoint when one point lies in a hole.
SELECT ST_Contains(a, b) FROM (SELECT 'POLYGON ((10 130,50 190,110 190,140 150,150 80,100 10,20 40,10 130),(70 40,100 50,120 80,80 110,50 90,70 40))'::geometry AS a, 'MULTIPOINT (99 130,87 70)'::geometry AS b ) AS example;
f
A Polygon does not contain a LineString extending outside it.
SELECT ST_Contains(a, b) FROM (SELECT 'POLYGON ((10 130,50 190,110 190,140 150,150 80,100 10,20 40,10 130))'::geometry AS a, 'LINESTRING (99 130,170 131)'::geometry AS b ) AS example;
f
På grund av villkoret för inre skärning returnerar ST_Contains FALSE i följande situationer (medan ST_Covers returnerar TRUE):
A LineString does not contain a Point lying only on its boundary.
SELECT ST_Contains(a, b), ST_Covers(a, b) FROM (SELECT 'LINESTRING (10 190,60 80,130 120,190 10)'::geometry AS a, 'POINT (190 10)'::geometry AS b ) AS example;
f | t
A Polygon does not contain a LineString lying entirely on its boundary.
SELECT ST_Contains(a, b), ST_Covers(a, b) FROM (SELECT 'POLYGON ((10 130,50 190,110 190,140 150,150 80,100 10,20 40,10 130))'::geometry AS a, 'LINESTRING (80 190,110 190,140 150,150 80)'::geometry AS b ) AS example;
f | t
This example tests a circle within another circle.
WITH circles AS (
SELECT ST_Buffer(center, 10) AS smallc,
ST_Buffer(center, 20) AS bigc
FROM (SELECT 'POINT(1 2)'::geometry AS center) AS p
)
SELECT
ST_Contains(smallc, bigc) AS smallcontainsbig,
ST_Contains(bigc, smallc) AS bigcontainssmall,
ST_Contains(bigc, ST_Union(smallc, bigc)) AS bigcontainsunion,
ST_Equals(bigc, ST_Union(smallc, bigc)) AS bigisunion,
ST_Covers(bigc, ST_ExteriorRing(bigc)) AS bigcoversexterior,
ST_Contains(bigc, ST_ExteriorRing(bigc)) AS bigcontainsexterior
FROM circles;
-[ RECORD 1 ]----- smallcontainsbig | f bigcontainssmall | t bigcontainsunion | t bigisunion | t bigcoversexterior | t bigcontainsexterior | f
This example demonstrates the difference between contains and contains-properly predicates.
SELECT
ST_GeometryType(geom_a) AS geomtype,
ST_Contains(geom_a, geom_a) AS acontainsa,
ST_ContainsProperly(geom_a, geom_a) AS acontainspropa,
ST_Contains(geom_a, ST_Boundary(geom_a)) AS acontainsba,
ST_ContainsProperly(geom_a, ST_Boundary(geom_a)) AS acontainspropba
FROM (VALUES
(ST_Buffer(ST_Point(1, 1), 5, 1)),
(ST_MakeLine(ST_Point(1, 1), ST_Point(-1, -1))),
(ST_Point(1, 1))
) AS foo(geom_a);
geomtype | acontainsa | acontainspropa | acontainsba | acontainspropba --------------+------------+----------------+-------------+----------------- ST_Polygon | t | f | f | f ST_LineString | t | f | f | f ST_Point | t | t | f | f
ST_ContainsProperly — Testar om varje punkt i B ligger i det inre av A
boolean ST_ContainsProperly(geometry geomA, geometry geomB);
Returnerar sant om varje punkt i B ligger i A:s inre (eller motsvarande, ingen punkt i B ligger i A:s gräns eller yttre).
I matematiska termer: ST_ContainsProperly(A, B) ⇔ Int(A) ⋂ B = B
A innehåller B på rätt sätt om DE-9IM-överskärningsmatrisen för de två geometrierna stämmer överens med [T**FF*FF*]
A innehåller inte riktigt sig själv, men innehåller sig själv.
Ett användningsområde för detta predikat är att beräkna skärningspunkterna mellan en uppsättning geometrier och en stor polygonal geometri. Eftersom intersektion är en ganska långsam operation kan det vara effektivare att använda containsProperly för att filtrera bort testgeometrier som ligger helt inom området. I dessa fall vet man på förhand att skärningspunkten är exakt den ursprungliga testgeometrin.
![]() | |
&index_aware; För att undvika indexanvändning, använd funktionen |
![]() | |
Fördelen med detta predikat jämfört med ST_Contains och ST_Intersects är att det kan beräknas mer effektivt, utan att behöva beräkna topologi på enskilda punkter. |
Utförs av GEOS-modulen.
Tillgänglighet: 1.4.0
Förbättrad: 3.0.0 aktiverade stöd för GEOMETRYCOLLECTION
![]() | |
Använd inte denna funktion med ogiltiga geometrier. Du kommer att få oväntade resultat. |
This example tests a circle within another circle.
WITH circles AS (
SELECT ST_Buffer(center, 10) AS smallc,
ST_Buffer(center, 20) AS bigc
FROM (SELECT 'POINT(1 2)'::geometry AS center) AS p
)
SELECT
ST_ContainsProperly(smallc, bigc) AS smallcontainspropbig,
ST_ContainsProperly(bigc, smallc) AS bigcontainspropsmall,
ST_ContainsProperly(bigc, ST_Union(smallc, bigc)) AS bigcontainspropunion,
ST_Equals(bigc, ST_Union(smallc, bigc)) AS bigisunion,
ST_Covers(bigc, ST_ExteriorRing(bigc)) AS bigcoversexterior,
ST_ContainsProperly(bigc, ST_ExteriorRing(bigc)) AS bigcontainsexterior
FROM circles;-[ RECORD 1 ]----- smallcontainspropbig | f bigcontainspropsmall | t bigcontainspropunion | f bigisunion | t bigcoversexterior | t bigcontainsexterior | f
This example demonstrates the difference between contains and contains-properly predicates.
WITH input(geom) AS (VALUES
(ST_Buffer(ST_Point(1, 1), 5, 1)),
(ST_MakeLine(ST_Point(1, 1), ST_Point(-1, -1))),
(ST_Point(1, 1))
)
SELECT ST_GeometryType(geom) AS geomtype,
ST_Contains(geom, geom) AS acontainsa,
ST_ContainsProperly(geom, geom) AS acontainspropa,
ST_Contains(geom, ST_Boundary(geom)) AS acontainsba,
ST_ContainsProperly(geom, ST_Boundary(geom)) AS acontainspropba
FROM input;geomtype | acontainsa | acontainspropa | acontainsba | acontainspropba --------------+------------+----------------+-------------+----------------- ST_Polygon | t | f | f | f ST_LineString | t | f | f | f ST_Point | t | t | f | f
ST_CoveredBy — Testar om varje punkt i A ligger i B
boolean ST_CoveredBy(geometry geomA, geometry geomB);
boolean ST_CoveredBy(geography geogA, geography geogB);
Returnerar true om varje punkt i Geometry/Geography A ligger inuti (dvs. skär insidan eller gränsen av) Geometry/Geography B. Testar på motsvarande sätt att ingen punkt i A ligger utanför (i utsidan av) B.
I matematiska termer: ST_CoveredBy(A, B) ⇔ A ⋂ B = A
ST_CoveredBy är det omvända av ST_Covers. Så ST_CoveredBy(A,B) = ST_Covers(B,A)..
Generellt bör denna funktion användas istället för ST_Within, eftersom den har en enklare definition som inte har den egenheten att "gränser inte ligger inom sin geometri".
![]() | |
&index_aware; För att undvika indexanvändning, använd funktionen |
Förbättrad: 3.0.0 aktiverade stöd för GEOMETRYCOLLECTION
![]() | |
Använd inte denna funktion med ogiltiga geometrier. Du kommer att få oväntade resultat. |
Utförs av GEOS-modulen
Tillgänglighet: 1.2.2
OBS: detta är den "tillåtna" versionen som returnerar ett boolean, inte ett heltal.
Inte en OGC-standard, men Oracle har den också.
This example tests a circle covered by another circle.
WITH circles AS (
SELECT ST_Buffer(center, 10) AS smallc,
ST_Buffer(center, 20) AS bigc
FROM (SELECT 'POINT(1 2)'::geometry AS center) AS p
)
SELECT
ST_CoveredBy(smallc, smallc) AS smallinsmall,
ST_CoveredBy(smallc, bigc) AS smallcoveredbybig,
ST_CoveredBy(ST_ExteriorRing(bigc), bigc) AS exteriorcoveredbybig,
ST_Within(ST_ExteriorRing(bigc), bigc) AS exteriorwithinbig
FROM circles;smallinsmall | smallcoveredbybig | exteriorcoveredbybig | exteriorwithinbig --------------+-------------------+----------------------+------------------ t | t | t | f (1 row)
ST_Covers — Testar om varje punkt i B ligger i A
boolean ST_Covers(geometry geomA, geometry geomB);
boolean ST_Covers(geography geogpolyA, geography geogpointB);
Returnerar true om varje punkt i Geometry/Geography B ligger inuti (dvs. skär insidan eller gränsen av) Geometry/Geography A. Testar på motsvarande sätt att ingen punkt i B ligger utanför (i utsidan av) A.
I matematiska termer: ST_Covers(A, B) ⇔ A ⋂ B = B
ST_Covers är det omvända av ST_CoveredBy. Alltså, ST_Covers (A,B) = ST_CoveredBy(B,A)..
Generellt bör denna funktion användas istället för ST_Contains, eftersom den har en enklare definition som inte har den egenheten att "geometrier inte innehåller sin gräns".
![]() | |
&index_aware; För att undvika indexanvändning, använd funktionen |
Förbättrad: 3.0.0 aktiverade stöd för GEOMETRYCOLLECTION
![]() | |
Använd inte denna funktion med ogiltiga geometrier. Du kommer att få oväntade resultat. |
Utförs av GEOS-modulen
Förbättrad: 2.4.0 Stöd för polygon i polygon och linje i polygon har lagts till för geograftyp
Förbättrad: 2.3.0 Förbättring av PIP-kortslutning för geometri utökad för att stödja MultiPoints med få punkter. Tidigare versioner stödde endast punkt i polygon.
Tillgänglighet: 1.5 - stöd för geografi infördes.
Tillgänglighet: 1.2.2
OBS: detta är den "tillåtna" versionen som returnerar ett boolean, inte ett heltal.
Inte en OGC-standard, men Oracle har den också.
Exempel på geometri
This example tests a circle covering another circle.
WITH circles AS (
SELECT ST_Buffer(center, 10) AS smallc,
ST_Buffer(center, 20) AS bigc
FROM (SELECT 'POINT(1 2)'::geometry AS center) AS p
)
SELECT
ST_Covers(smallc, smallc) AS smallinsmall,
ST_Covers(smallc, bigc) AS smallcoversbig,
ST_Covers(bigc, ST_ExteriorRing(bigc)) AS bigcoversexterior,
ST_Contains(bigc, ST_ExteriorRing(bigc)) AS bigcontainsexterior
FROM circles;smallinsmall | smallcoversbig | bigcoversexterior | bigcontainsexterior --------------+----------------+-------------------+--------------------- t | f | t | f (1 row)
Geography example
This example compares a point with a 300-meter buffer against a point and against a 10-meter buffer around that point.
SELECT ST_Covers(geog_poly, geog_pt) As poly_covers_pt,
ST_Covers(ST_Buffer(geog_pt, 10), geog_pt) As buff_10m_covers_cent
FROM (SELECT ST_Buffer('SRID=4326;POINT(-99.327 31.4821)'::geography, 300) As geog_poly,
'SRID=4326;POINT(-99.33 31.483)'::geography As geog_pt ) As foo;poly_covers_pt | buff_10m_covers_cent ----------------+------------------ f | t
ST_Crosses — Testar om två geometrier har vissa, men inte alla, inre punkter gemensamt
boolean ST_Crosses(geometry g1, geometry g2);
Jämför två geometriobjekt och returnerar true om deras skärningspunkt "korsar varandra spatialtt", dvs. geometrierna har vissa men inte alla inre punkter gemensamma. Skärningspunkten mellan geometriernas inre punkter måste vara icke-tom och ha en dimension som är mindre än den maximala dimensionen för de två geometrierna i indata, och skärningspunkten mellan de två geometrierna får inte vara lika med någon av geometrierna. I annat fall returneras false. Crosses-relationen är symmetrisk och irreflexiv.
I matematiska termer: ST_Crosses(A, B) ⇔ (dim( Int(A) ⋂ Int(B) ) < max( dim( Int(A) ), dim( Int(B) ) )) ∧ (A ⋂ B ≠ A) ∧ (A ⋂ B ≠ B)
Geometrier korsas om deras DE-9IM Intersection Matrix matchar:
T*T****** för situationerna Point/Line, Point/Area och Line/Area
T*****T** för Line/Point-, Area/Point- och Area/Line-situationer
0******** för Line/Line-situationer
resultatet är falskt för Point/Point- och Area/Area-situationer
![]() | |
OpenGIS Simple Features Specification definierar detta predikat endast för situationerna Point/Line, Point/Area, Line/Line och Line/Area. JTS / GEOS utökar definitionen till att även gälla Line/Point, Area/Point och Area/Line situationer. Detta gör relationen symmetrisk. |
![]() | |
Denna funktion inkluderar automatiskt en jämförelse av begränsningsrutor som använder alla spatiala index som finns tillgängliga för geometrierna. |
Förbättrad: 3.0.0 aktiverade stöd för GEOMETRYCOLLECTION
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s2.1.13.3
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.29
Följande situationer returnerar alla true.
A LineString crosses a MultiPoint when some, but not all, points lie on the line.
SELECT ST_Crosses(a, b) FROM (SELECT 'LINESTRING (10 190,60 80,130 120,190 10)'::geometry AS a, 'MULTIPOINT (80 170,120 13,130 120,181 142)'::geometry AS b ) AS example;
t
A Polygon crosses a MultiPoint when some, but not all, points lie in its interior.
SELECT ST_Crosses(a, b) FROM (SELECT 'POLYGON ((30 190,10 100,10 10,90 20,110 70,80 130,30 190))'::geometry AS a, 'MULTIPOINT (56 60,120 13,130 119,181 142)'::geometry AS b ) AS example;
t
A LineString crosses a Polygon when part of the line lies inside and part outside.
SELECT ST_Crosses(a, b) FROM (SELECT 'POLYGON ((30 190,10 100,10 10,90 20,110 70,80 130,30 190))'::geometry AS a, 'LINESTRING (30 40,70 50,120 150,190 190)'::geometry AS b ) AS example;
t
Two LineStrings cross when they share an interior point.
SELECT ST_Crosses(a, b) FROM (SELECT 'LINESTRING (10 190,60 80,130 120,190 10)'::geometry AS a, 'LINESTRING (10 10,70 30,110 120,190 190)'::geometry AS b ) AS example;
t
Tänk dig en situation där en användare har två tabeller: en tabell med vägar och en tabell med motorvägar.
Code CREATE TABLE roads ( id serial NOT NULL, geom geometry, CONSTRAINT roads_pkey PRIMARY KEY (road_id) );
|
Code CREATE TABLE highways ( id serial NOT NULL, the_gem geometry, CONSTRAINT roads_pkey PRIMARY KEY (road_id) );
|
För att få fram en lista över vägar som korsar en motorväg, använd en fråga som liknar:
SELECT roads.id FROM roads, highways WHERE ST_Crosses(roads.geom, highways.geom);
ST_Disjoint — Testar om två geometrier inte har några gemensamma punkter
boolean ST_Disjoint( geometry A , geometry B );
Returnerar sant om två geometrier är disjunkta. Geometrier är disjunkta om de inte har någon gemensam punkt.
Om något annat spatialt förhållande är sant för ett par geometrier är de inte disjunkta. Disjunkt innebär att ST_Intersects är falskt.
I matematiska termer: ST_Disjoint(A, B) ⇔ A ⋂ B = ∅
Förbättrad: 3.0.0 aktiverade stöd för GEOMETRYCOLLECTION
Utförs av GEOS-modulen
![]() | |
Detta funktionsanrop använder inte index. Ett negerat ST_Intersects -predikat kan användas som ett mer performant alternativ som använder index: |
![]() | |
OBS: detta är den "tillåtna" versionen som returnerar ett boolean, inte ett heltal. |
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s2.1.1.2 //s2.1.13.3 - a.Relate(b, 'FF*FF****')
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.26
SELECT ST_Disjoint('POINT(0 0)'::geometry, 'LINESTRING ( 2 0,0 2 )'::geometry);t
SELECT ST_Disjoint('POINT(0 0)'::geometry, 'LINESTRING ( 0 0,0 2 )'::geometry);f
ST_Equals — Testar om två geometrier innehåller samma uppsättning punkter
boolean ST_Equals(geometry A, geometry B);
Returnerar sant om de givna geometrierna är "topologiskt lika". Använd detta för ett "bättre" svar än "=". Topologisk likhet innebär att geometrierna har samma dimension och att deras punktuppsättningar upptar samma utrymme. Detta innebär att ordningen på hörnen kan vara olika i topologiskt lika geometrier. För att verifiera att punktordningen är konsekvent använd ST_OrderingEquals (det måste noteras att ST_OrderingEquals är lite strängare än att bara verifiera att punktordningen är densamma).
I matematiska termer: ST_Equals(A, B) ⇔ A = B
Följande relation gäller: ST_Equals(A, B) ⇔ ST_Within(A,B) ∧ ST_Within(B,A)
Förbättrad: 3.0.0 aktiverade stöd för GEOMETRYCOLLECTION
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s2.1.1.2
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.24
Ändrad: 2.2.0 Returnerar sant även för ogiltiga geometrier om de är binärt lika
SELECT ST_Equals('LINESTRING(0 0,10 10)',
'LINESTRING(0 0,5 5,10 10)');t
SELECT ST_Equals(ST_Reverse('LINESTRING(0 0,10 10)'),
'LINESTRING(0 0,5 5,10 10)');t
ST_Intersects — Testar om två geometrier skär varandra (de har minst en gemensam punkt)
boolean ST_Intersects( geometry geomA , geometry geomB );
boolean ST_Intersects( geography geogA , geography geogB );
Returnerar true om två geometrier korsar varandra. Geometrier korsar varandra om de har någon gemensam punkt.
För geografi används en avståndstolerans på 0,00001 meter (så att punkter som ligger mycket nära varandra anses korsa varandra).
I matematiska termer: ST_Intersects(A, B) ⇔ A ⋂ B ≠ ∅
Geometrier skär varandra om deras DE-9IM Intersection Matrix matchar en av följande:
T********
*T*******
***T*****
****T****
Spatial korsning är underförstådd i alla andra tester av spatiala relationer, utom ST_Disjoint, som testar att geometrier INTE korsar varandra.
![]() | |
Denna funktion inkluderar automatiskt en jämförelse av begränsningsrutor som använder alla spatiala index som finns tillgängliga för geometrierna. |
Ändrad: 3.0.0 SFCGAL-versionen har tagits bort och inbyggt stöd för 2D TINS har lagts till.
Förbättrad: 2.5.0 Stöder GEOMETRYCOLLECTION.
Förbättrad: 2.3.0 Förbättring av PIP-kortslutning utökad till att stödja MultiPoints med få punkter. Tidigare versioner stödde endast punkt i polygon.
Utförs av GEOS-modulen (för geometri), geografi är inhemsk
Tillgänglighet: 1.5 stöd för geografi infördes.
![]() | |
För geografi har denna funktion en avståndstolerans på cirka 0,00001 meter och använder sfären i stället för sfäroidberäkning. |
![]() | |
OBS: detta är den "tillåtna" versionen som returnerar ett boolean, inte ett heltal. |
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s2.1.1.2 //s2.1.13.3 - ST_Intersects(g1, g2 ) --> Not (ST_Disjoint(g1, g2 ))
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.27
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
SELECT ST_Intersects('POINT(0 0)'::geometry, 'LINESTRING ( 2 0,0 2 )'::geometry);f
SELECT ST_Intersects('POINT(0 0)'::geometry, 'LINESTRING ( 0 0,0 2 )'::geometry);t
This example looks up rows in a table; for faster lookup, the geometry column should have a GiST index.
SELECT id, name FROM cities WHERE ST_Intersects(geom, 'SRID=4326;POLYGON((28 53,27.707 52.293,27 52,26.293 52.293,26 53,26.293 53.707,27 54,27.707 53.707,28 53))');
id | name ----+------- 2 | Minsk (1 row)
SELECT ST_Intersects('SRID=4326;LINESTRING(-43.23456 72.4567,-43.23456 72.4568)'::geography,
'SRID=4326;POINT(-43.23456 72.4567772)'::geography
);t
ST_LineCrossingDirection — Returnerar ett tal som anger korsningsbeteendet för två LineStrings
integer ST_LineCrossingDirection(geometry linestringA, geometry linestringB);
Givet två linestringsar returnerar ett heltal mellan -3 och 3 som indikerar vilken typ av korsningsbeteende som finns mellan dem. 0 indikerar ingen korsning. Detta stöds endast för LINESTRINGs.
Korsningsnumret har följande innebörd:
0: LINJE UTAN KORS
-1: LINJE KORS VÄNSTER
1: LINJE KORS HÖGER
-2: LINJE MULTIKORS SLUT VÄNSTER
2: LINJE MULTIKORS SLUT HÖGER
-3: LINJE FLERKORS SLUT SAMMA FÖRSTA VÄNSTER
3: LINJE MULTIKORS SLUT SAMMA FÖRSTA HÖGER
Tillgänglighet: 1.4
Exempel: LINE CROSS LEFT och LINE CROSS RIGHT
SELECT ST_LineCrossingDirection(lineA, lineB) As A_cross_B,
ST_LineCrossingDirection(lineB, lineA) As B_cross_A
FROM (SELECT
'LINESTRING(25 169,89 114,40 70,86 43)'::geometry As lineA,
'LINESTRING (20 140,71 74,161 53)'::geometry As lineB
) As foo;A_cross_B | B_cross_A
-----------+-----------
-1 | 1Exempel: LINJE MULTICROSS SLUT SAME FÖRSTA VÄNSTER och LINJE MULTICROSS SLUT SAME FÖRSTA HÖGER
SELECT ST_LineCrossingDirection(lineA, lineB) As A_cross_B,
ST_LineCrossingDirection(lineB, lineA) As B_cross_A
FROM (SELECT
'LINESTRING(25 169,89 114,40 70,86 43)'::geometry As lineA,
'LINESTRING(171 154,20 140,71 74,161 53)'::geometry As lineB
) As foo;A_cross_B | B_cross_A
-----------+-----------
3 | -3Exempel: LINE MULTICROSS END LEFT och LINE MULTICROSS END RIGHT
SELECT ST_LineCrossingDirection(lineA, lineB) As A_cross_B,
ST_LineCrossingDirection(lineB, lineA) As B_cross_A
FROM (SELECT
'LINESTRING(25 169,89 114,40 70,86 43)'::geometry As lineA,
'LINESTRING(5 90,71 74,20 140,171 154)'::geometry As lineB
) As foo;A_cross_B | B_cross_A
-----------+-----------
-2 | 2Exempel: Hittar alla gator som korsar
SELECT s1.gid, s2.gid, ST_LineCrossingDirection(s1.geom, s2.geom)
FROM streets s1 CROSS JOIN streets s2
ON (s1.gid != s2.gid AND s1.geom && s2.geom )
WHERE ST_LineCrossingDirection(s1.geom, s2.geom)
> 0;
ST_OrderingEquals — Testar om två geometrier representerar samma geometri och har punkter i samma riktningsordning
boolean ST_OrderingEquals(geometry A, geometry B);
ST_OrderingEquals jämför två geometrier och returnerar t (TRUE) om geometrierna är lika och koordinaterna är i samma ordning, annars returnerar den f (FALSE).
![]() | |
Denna funktion är implementerad enligt ArcSDE SQL-specifikationen snarare än SQL-MM. http://edndoc.esri.com/arcsde/9.1/sql_api/sqlapi3.htm#ST_OrderingEquals |
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.43
SELECT ST_OrderingEquals('LINESTRING(0 0,10 10)',
'LINESTRING(0 0,5 5,10 10)');f
SELECT ST_OrderingEquals('LINESTRING(0 0,10 10)',
'LINESTRING(0 0,10 10)');t
SELECT ST_OrderingEquals('POLYGON((0 0,0 1,1 1,1 0,0 0))',
'POLYGON((0 0,1 0,1 1,0 1,0 0))');f
ST_Overlaps — Testar om två geometrier har samma dimension och skär varandra, men var och en har minst en punkt som inte finns i den andra
boolean ST_Overlaps(geometry A, geometry B);
Returnerar TRUE om geometri A och B "överlappar varandra spatialt". Två geometrier överlappar varandra om de har samma dimension, deras interiörer skär varandra i den dimensionen och var och en har minst en punkt inuti den andra (eller motsvarande, ingen av dem täcker den andra). Överlappningsrelationen är symmetrisk och irreflexiv.
I matematiska termer: ST_Overlaps(A, B) ⇔ ( dim(A) = dim(B) = dim( Int(A) ⋂ Int(B) )) ∧ (A ⋂ B ≠ A) ∧ (A ⋂ B ≠ B)
![]() | |
&index_aware; För att undvika indexanvändning, använd funktionen |
Utförs av GEOS-modulen
Förbättrad: 3.0.0 aktiverade stöd för GEOMETRYCOLLECTION
OBS: detta är den "tillåtna" versionen som returnerar ett boolean, inte ett heltal.
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s2.1.1.2 // s2.1.13.3
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.32
ST_Overlaps returnerar TRUE i följande situationer:
Two MultiPoints overlap when they share some, but not all, points.
SELECT ST_Overlaps(a, b) FROM (SELECT 'MULTIPOINT ((20 20),(40 90),(80 130),(140 100),(110 40),(120 170),(150 70))'::geometry AS a, 'MULTIPOINT ((180 10),(40 90),(80 130),(160 150),(110 40),(50 50),(50 160))'::geometry AS b ) AS example;
t
Two LineStrings overlap along part of their paths.
SELECT ST_Overlaps(a, b) FROM (SELECT 'LINESTRING (10 10,40 90,70 110,140 110,170 130,190 190)'::geometry AS a, 'LINESTRING (10 190,50 130,90 110,130 110,160 70,180 10)'::geometry AS b ) AS example;
t
Two Polygons overlap where their interiors intersect and neither contains the other.
SELECT ST_Overlaps(a, b) FROM (SELECT 'POLYGON ((140 140,140 122,135 105,126 100,118 99,110 94,100 86,97 73,102 59,98 49,87 38,70 30,55 29,40 30,28 38,20 50,14 66,10 84,6 100,4 119,4 143,6 166,10 180,18 191,28 195,40 190,55 189,67 186,86 179,112 165,124 158,133 148,140 140),(48 177,40 177,30 174,24 166,22 159,25 155,30 153,40 154,45 157,52 162,53 169,51 174,48 177))'::geometry AS a, 'POLYGON ((75 63,79 50,87 38,95 31,108 25,124 22,140 18,154 11,166 6,176 10,184 21,188 35,190 58,190 82,193 104,190 121,185 139,178 154,166 163,154 171,139 172,124 171,112 165,96 152,92 142,92 126,86 116,79 110,75 104,72 94,73 86,75 76,75 63))'::geometry AS b ) AS example;
t
En punkt på en LineString är innesluten, men eftersom den har en lägre dimension överlappar eller korsar den inte varandra.
SELECT ST_Overlaps(a, b) AS overlaps, ST_Crosses(a, b) AS crosses,
ST_Intersects(a, b) AS intersects, ST_Contains(b, a) AS b_contains_a
FROM (SELECT 'POINT (100 100)'::geometry As a,
'LINESTRING (30 50,40 160,160 40,180 160)'::geometry AS b) AS toverlaps | crosses | intersects | b_contains_a ---------+----------------------+-------------- f | f | t | t
En LineString som delvis täcker en Polygon skär och korsar, men överlappar inte eftersom den har olika dimensioner.
SELECT ST_Overlaps(a, b) AS overlaps, ST_Crosses(a, b) AS crosses,
ST_Intersects(a, b) AS intersects, ST_Contains(a, b) AS contains
FROM (SELECT 'POLYGON ((40 170,90 30,180 100,40 170))'::geometry AS a,
'LINESTRING(10 10,190 190)'::geometry AS b) AS t;overlap | crosses | intersects | contains ---------+---------+------------+-------------- f | t | t | f
Två polygoner som skär varandra men där ingen av dem är innesluten i den andra överlappar varandra, men korsar inte varandra eftersom deras skärningspunkt har samma dimension.
SELECT ST_Overlaps(a, b) AS overlaps, ST_Crosses(a, b) AS crosses,
ST_Intersects(a, b) AS intersects, ST_Contains(b, a) AS b_contains_a,
ST_Dimension(a) AS dim_a, ST_Dimension(b) AS dim_b,
ST_Dimension(ST_Intersection(a, b)) AS dim_int
FROM (SELECT 'POLYGON ((40 170,90 30,180 100,40 170))'::geometry AS a,
'POLYGON ((110 180,20 60,130 90,110 180))'::geometry AS b) As t;overlaps | crosses | intersects | b_contains_a | dim_a | dim_b | dim_int ----------+---------+------------+--------------+-------+-------+----------- t | f | t | f | 2 | 2 | 2
ST_Relate — Testar om två geometrier har en topologisk relation som matchar ett Intersection Matrix-mönster, eller beräknar deras Intersection Matrix
boolean ST_Relate(geometry geomA, geometry geomB, text intersectionMatrixPattern);
text ST_Relate(geometry geomA, geometry geomB);
text ST_Relate(geometry geomA, geometry geomB, integer boundaryNodeRule);
Dessa funktioner gör det möjligt att testa och utvärdera det spatiala (topologiska) förhållandet mellan två geometrier, enligt definitionen i Dimensionally Extended 9-Intersection Model (DE-9IM).
DE-9IM specificeras som en matris med 9 element som anger dimensionen på skärningspunkterna mellan inre, yttre och yttre delar av två geometrier. Den representeras av en textsträng med 9 tecken som använder symbolerna "F", "0", "1", "2" (t.ex. "FF1FF0102").
En viss typ av spatial relation kan testas genom att matcha intersektionsmatrisen med ett intersektionsmatrismönster. Mönster kan innehålla tilläggssymbolerna "T" (som betyder "skärningspunkten är inte tom") och "*" (som betyder "vilket värde som helst"). Vanliga spatiala relationer tillhandahålls av de namngivna funktionerna ST_Contains, ST_ContainsProperly, ST_Covers, ST_CoveredBy, ST_Crosses, ST_Disjoint, ST_Equals, ST_Intersects, ST_Overlaps, ST_Touches, och ST_Within. Genom att använda ett explicit mönster kan man testa flera villkor för skärningar, korsningar osv. i ett steg. Det gör det också möjligt att testa spatiala relationer som inte har en namngiven spatial relationsfunktion. Till exempel har relationen "Interior-Intersects" DE-9IM-mönstret T********, som inte utvärderas av något namngivet predikat.
Mer information finns på Avsnitt 5.1, ”Fastställande av spatiala relationer”.
Variant 1: Testar om två geometrier är spatialt relaterade enligt det angivna intersectionMatrixPattern.
![]() | |
Till skillnad från de flesta namngivna spatiala relationspredikaten innehåller detta INTE automatiskt ett indexanrop. Anledningen är att vissa relationer är sanna för geometrier som INTE korsar varandra (t.ex. Disjoint). Om du använder ett relationsmönster som kräver intersektion, inkludera då indexanropet &&. |
![]() | |
Det är bättre att använda en namngiven relationsfunktion om en sådan finns tillgänglig, eftersom de automatiskt använder ett spatialt index om ett sådant finns. De kan också implementera prestandaoptimeringar som inte är tillgängliga med fullständig relationsutvärdering. |
Variant 2: Returnerar DE-9IM-matrissträngen för det spatiala förhållandet mellan de två indatageometrierna. Matrissträngen kan testas för att matcha ett DE-9IM-mönster med hjälp av ST_RelateMatch.
Variant 3: Som variant 2, men tillåter specificering av en Boundary Node Rule. En Boundary Node Rule ger möjlighet till finare kontroll över om MultiLineStrings ändpunkter anses ligga i DE-9IM Interior eller Boundary. Värdena för boundaryNodeRule är:
1: OGC-Mod2 - linjens ändpunkter är i Boundary om de förekommer ett udda antal gånger. Detta är den regel som definieras av OGC SFS-standarden och är standard för ST_Relate.
2: Slutpunkt - alla slutpunkter ligger i Boundary.
3: MultivalentEndpoint - ändpunkterna är i Boundary om de förekommer mer än en gång. Med andra ord är gränsen alla de "anslutna" eller "inre" ändpunkterna (men inte de "icke anslutna/yttre").
4: MonovalentEndpoint - ändpunkterna ligger i Boundary om de bara förekommer en gång. Med andra ord är gränsen alla de "obundna" eller "yttre" ändpunkterna.
Denna funktion finns inte i OGC-specifikationen, men är underförstådd. se s2.1.13.2
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s2.1.1.2 // s2.1.13.3
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.25
Utförs av GEOS-modulen
Förbättrad: 2.0.0 - stöd för att ange en regel för gränsnoder har lagts till.
Förbättrad: 3.0.0 aktiverade stöd för GEOMETRYCOLLECTION
Använda den booleska värderingsfunktionen för att testa spatiala relationer.
SELECT ST_Relate('POINT(1 2)', ST_Buffer('POINT(1 2)', 2), '0FFFFF212');t
SELECT ST_Relate('POINT(1 2)', ST_Buffer('POINT(1 2)', 2), '*FF*FF212');t
Testa ett anpassat spatialt relationsmönster som ett frågevillkor, med && för att aktivera användning av ett spatialt index.
Find compounds that properly intersect (not just touch) a poly (Interior Intersects)
SELECT c.* , p.name As poly_name
FROM polys AS p
INNER JOIN compounds As c
ON c.geom && p.geom
AND ST_Relate(p.geom, c.geom, 'T********');
Beräkning av intersektionsmatrisen för spatiala relationer.
SELECT ST_Relate('POINT(1 2)',
ST_Buffer('POINT(1 2)', 2));0FFFFF212
SELECT ST_Relate('LINESTRING(1 2,3 4)',
'LINESTRING(5 6,7 8)' );FF1FF0102
Använda olika Boundary Node Rules för att beräkna det spatiala förhållandet mellan en LineString och en MultiLineString med en duplicerad ändpunkt (3 3)::
Med hjälp av OGC-Mod2-regeln (1) är den duplicerade ändpunkten i det inre av MultiLineString, så DE-9IM-matrisposten [aB:bI] är 0 och [aB:bB] är F..
Med hjälp av ändpunktsregeln (2) ligger den duplicerade ändpunkten i gränsen för MultiLineString, så DE-9IM-matrisens post [aB:bI] är F och [aB:bB] är 0..
WITH data AS (SELECT
'LINESTRING(1 1,3 3)'::geometry AS a_line,
'MULTILINESTRING((3 3,3 5),(3 3,5 3))'::geometry AS b_multiline
)
SELECT ST_Relate(a_line, b_multiline, 1) AS bnr_mod2,
ST_Relate(a_line, b_multiline, 2) AS bnr_endpoint
FROM data;bnr_mod2 | bnr_endpoint -----------+-------------- FF10F0102 | FF1F00102
ST_RelateMatch — Testar om en DE-9IM Intersection Matrix matchar ett Intersection Matrix-mönster
boolean ST_RelateMatch(text intersectionMatrix, text intersectionMatrixPattern);
Testar om ett intersectionMatrix-värde enligt Dimensionally Extended 9-Intersection Model (DE-9IM) uppfyller ett intersectionMatrixPattern. Värden för intersektionsmatriser kan beräknas med ST_Relate.
Mer information finns på Avsnitt 5.1, ”Fastställande av spatiala relationer”.
Utförs av GEOS-modulen
Tillgänglighet: 2.0.0
SELECT ST_RelateMatch('101202FFF', 'TTTTTTFFF') ;t
Mönster för vanliga spatiala relationer matchade mot intersektionsmatrisvärden, för en linje i olika positioner i förhållande till en polygon
SELECT pat.name AS relationship, pat.val AS pattern,
mat.name AS position, mat.val AS matrix,
ST_RelateMatch(mat.val, pat.val) AS match
FROM (VALUES ( 'Equality', 'T1FF1FFF1' ),
( 'Overlaps', 'T*T***T**' ),
( 'Within', 'T*F**F***' ),
( 'Disjoint', 'FF*FF****' )) AS pat(name, val)
CROSS JOIN
(VALUES ('non-intersecting', 'FF1FF0212'),
('overlapping', '1010F0212'),
('inside', '1FF0FF212')) AS mat(name, val);relationship | pattern | position | matrix | match --------------+-----------+------------------+-----------+------- Equality | T1FF1FFF1 | non-intersecting | FF1FF0212 | f Equality | T1FF1FFF1 | overlapping | 1010F0212 | f Equality | T1FF1FFF1 | inside | 1FF0FF212 | f Overlaps | T*T***T** | non-intersecting | FF1FF0212 | f Overlaps | T*T***T** | overlapping | 1010F0212 | t Overlaps | T*T***T** | inside | 1FF0FF212 | f Within | T*F**F*** | non-intersecting | FF1FF0212 | f Within | T*F**F*** | overlapping | 1010F0212 | f Within | T*F**F*** | inside | 1FF0FF212 | t Disjoint | FF*FF**** | non-intersecting | FF1FF0212 | t Disjoint | FF*FF**** | overlapping | 1010F0212 | f Disjoint | FF*FF**** | inside | 1FF0FF212 | f
ST_Touches — Testar om två geometrier har minst en gemensam punkt, men deras inre delar inte skär varandra
boolean ST_Touches(geometry A, geometry B);
Returnerar TRUE om A och B skär varandra, men deras interiörer inte skär varandra. På motsvarande sätt har A och B minst en gemensam punkt och de gemensamma punkterna ligger inom minst en gräns. För Point/Point-indata är relationen alltid FALSK, eftersom punkter inte har någon gräns.
I matematiska termer: ST_Touches(A, B) ⇔ (Int(A) ⋂ Int(B) = ∅) ∧ (A ⋂ B ≠ ∅)
Detta förhållande gäller om DE-9IM Intersection Matrix för de två geometrierna matchar en av:
FT*******
F**T*****
F***T****
![]() | |
&index_aware; För att undvika att använda ett index, använd |
Förbättrad: 3.0.0 aktiverade stöd för GEOMETRYCOLLECTION
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s2.1.1.2 // s2.1.13.3
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.28
Predikatet ST_Touches returnerar TRUE i följande exempel.
Two Polygons touching along a boundary segment.
SELECT ST_Touches(a, b) FROM (SELECT 'POLYGON ((10 190,10 70,80 70,80 130,50 160,120 160,120 190,10 190))'::geometry AS a, 'POLYGON ((80 110,140 140,190 110,180 40,140 10,80 50,80 70,80 110))'::geometry AS b ) AS example;
t
Two Polygons touching at a boundary point.
SELECT ST_Touches(a, b) FROM (SELECT 'POLYGON ((10 190,10 70,80 70,80 130,50 160,120 160,120 190,10 190))'::geometry AS a, 'POLYGON ((140 140,190 110,180 40,140 10,80 70,140 140))'::geometry AS b ) AS example;
t
A Polygon and a LineString touching at the line endpoint.
SELECT ST_Touches(a, b) FROM (SELECT 'POLYGON ((80 10,50 40,50 90,80 130,140 120,160 70,140 30,80 10))'::geometry AS a, 'LINESTRING (30 190,180 150,160 70)'::geometry AS b ) AS example;
t
Two LineStrings touching at their endpoints.
SELECT ST_Touches(a, b) FROM (SELECT 'LINESTRING (10 10,60 140,140 190)'::geometry AS a, 'LINESTRING (140 190,190 10)'::geometry AS b ) AS example;
t
Two LineStrings touching where an endpoint meets the other line.
SELECT ST_Touches(a, b) FROM (SELECT 'LINESTRING (10 10,60 140,140 190)'::geometry AS a, 'LINESTRING (60 140,190 10)'::geometry AS b ) AS example;
t
A Point touching a Polygon boundary.
SELECT ST_Touches(a, b) FROM (SELECT 'POLYGON ((30 30,10 110,40 190,120 170,180 180,170 100,130 10,30 30))'::geometry AS a, 'POINT (170 100)'::geometry AS b ) AS example;
t
SELECT ST_Touches('LINESTRING(0 0,1 1,0 2)'::geometry, 'POINT(1 1)'::geometry);f
SELECT ST_Touches('LINESTRING(0 0,1 1,0 2)'::geometry, 'POINT(0 2)'::geometry);t
ST_Within — Testar om varje punkt i A ligger i B, och deras interiörer har en gemensam punkt
boolean ST_Within(geometry A, geometry B);
Returnerar TRUE om geometri A ligger inom geometri B. A ligger inom B om och endast om alla punkter i A ligger inom (dvs. i det inre eller på gränsen till) B (eller motsvarande, inga punkter i A ligger i det yttre av B), och det inre av A och B har minst en punkt gemensamt.
För att denna funktion ska vara meningsfull måste båda källgeometrierna ha samma koordinatprojektion och samma SRID.
I matematiska termer: ST_Within(A, B) ⇔ (A ⋂ B = A) ∧ (Int(A) ⋂ Int(B) ≠ ∅)
Within-relationen är reflexiv: varje geometri är inom sig själv. Relationen är antisymmetrisk: om ST_Within(A,B) = true och ST_Within(B,A) = true, så måste de två geometrierna vara topologiskt lika(ST_Equals(A,B) = true).
ST_Within är det omvända av ST_Contains. Så ST_Within(A,B) = ST_Contains(B,A)..
![]() | |
Eftersom interiörerna måste ha en gemensam punkt är en finess i definitionen att linjer och punkter som ligger helt inom polygoners eller linjers gränser inte är inom geometrin. För ytterligare detaljer se Subtiliteter i OGC Covers, Contains, Within. Predikatet ST_CoveredBy ger en mer inkluderande relation. |
![]() | |
&index_aware; För att undvika indexanvändning, använd funktionen |
Utförs av GEOS-modulen
Förbättrad: 2.3.0 Förbättring av PIP-kortslutning för geometri utökad för att stödja MultiPoints med få punkter. Tidigare versioner stödde endast punkt i polygon.
Förbättrad: 3.0.0 aktiverade stöd för GEOMETRYCOLLECTION
![]() | |
Använd inte denna funktion med ogiltiga geometrier. Du kommer att få oväntade resultat. |
OBS: detta är den "tillåtna" versionen som returnerar ett boolean, inte ett heltal.
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s2.1.1.2 // s2.1.13.3 - a.Relate(b, 'T*F**F***')
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.30
This example defines two concentric circles once in a CTE so the same inputs can be rendered and then reused in related predicate checks.
WITH circles AS (
SELECT ST_Buffer(center, 20) AS smallc,
ST_Buffer(center, 40) AS bigc
FROM (SELECT 'POINT(50 50)'::geometry AS center) AS p
)
SELECT smallc AS small_circle,
bigc AS big_circle
FROM circles;POLYGON((70 50,69.616 46.098,68.478 42.346,66.629 38.889,64.142 35.858,61.111 33.371,57.654 31.522,53.902 30.384,50 30,46.098 30.384,42.346 31.522,38.889 33.371,35.858 35.858,33.371 38.889,31.522 42.346,30.384 46.098,30 50,30.384 53.902,31.522 57.654,33.371 61.111,35.858 64.142,38.889 66.629,42.346 68.478,46.098 69.616,50 70,53.902 69.616,57.654 68.478,61.111 66.629,64.142 64.142,66.629 61.111,68.478 57.654,69.616 53.902,70 50)) | POLYGON((90 50,89.231 42.196,86.955 34.693,83.259 27.777,78.284 21.716,72.223 16.741,65.307 13.045,57.804 10.769,50 10,42.196 10.769,34.693 13.045,27.777 16.741,21.716 21.716,16.741 27.777,13.045 34.693,10.769 42.196,10 50,10.769 57.804,13.045 65.307,16.741 72.223,21.716 78.284,27.777 83.259,34.693 86.955,42.196 89.231,50 90,57.804 89.231,65.307 86.955,72.223 83.259,78.284 78.284,83.259 72.223,86.955 65.307,89.231 57.804,90 50))
Using the same circles, ST_Within is reflexive on each circle, false from the larger circle into the smaller one, and true for ST_Union only when the union does not extend beyond the larger circle.
WITH circles AS (
SELECT ST_Buffer(center, 20) AS smallc,
ST_Buffer(center, 40) AS bigc
FROM (SELECT 'POINT(50 50)'::geometry AS center) AS p
)
SELECT
ST_Within(smallc, smallc) AS smallinsmall,
ST_Within(smallc, bigc) AS smallinbig,
ST_Within(bigc, smallc) AS biginsmall,
ST_Within(ST_Union(smallc, bigc), bigc) AS unioninbig,
ST_Within(bigc, ST_Union(smallc, bigc)) AS biginunion,
ST_Equals(bigc, ST_Union(smallc, bigc)) AS bigisunion
FROM circles;t | t | f | t | t | t
ST_3DDWithin — Testar om två 3D-geometrier befinner sig inom ett givet 3D-avstånd
boolean ST_3DDWithin(geometry g1, geometry g2, double precision distance_of_srid);
Returnerar true om 3D-avståndet mellan två geometrivärden inte är större än distance distance_of_srid. Avståndet anges i enheter som definieras av geometriernas spatiala referenssystem. För att denna funktion ska vara meningsfull måste källgeometrierna befinna sig i samma koordinatsystem (ha samma SRID).
![]() | |
Denna funktion inkluderar automatiskt en jämförelse av begränsningsrutor som använder alla spatiala index som finns tillgängliga för geometrierna. |
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM ?
Tillgänglighet: 2.0.0
Compare the same transformed point and line in both 3D and 2D. The 3D test fails because the Z difference matters even though the 2D footprints are close enough.
WITH sample AS (
SELECT ST_Transform('SRID=4326;POINT(-72.1235 42.3521 4)'::geometry, 2163) AS input_point,
ST_Transform(
'SRID=4326;LINESTRING(-72.1260 42.45 15,-72.123 42.1546 20)'::geometry,
2163
) AS input_line
)
SELECT ST_3DDWithin(input_point, input_line, 126.8) AS within_dist_3d,
ST_DWithin(input_point, input_line, 126.8) AS within_dist_2d,
input_point AS input_point,
input_line AS input_line
FROM sample;-[ RECORD 1 ]--+---------------------------------------------------------------------------------------------------------------------------------- within_dist_3d | f within_dist_2d | t input_point | POINT Z (-11774128.9 5237160.2 4) input_line | LINESTRING Z (-11774339.5 5243556.8 15,-11773706.7 5215256.3 20)
ST_3DDFullyWithin — Testar om två 3D-geometrier är helt inom ett givet 3D-avstånd
boolean ST_3DDFullyWithin(geometry g1, geometry g2, double precision distance);
Returnerar true om 3D-geometrierna är helt inom det angivna avståndet från varandra. Avståndet anges i enheter som definieras av geometriernas spatiala referenssystem. För att denna funktion ska vara meningsfull måste båda källgeometrierna ha samma koordinatprojektion och samma SRID.
![]() | |
Denna funktion inkluderar automatiskt en jämförelse av begränsningsrutor som använder alla spatiala index som finns tillgängliga för geometrierna. |
Tillgänglighet: 2.0.0
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
This example compares distance-within predicates in 2D and 3D. The point is distance-within the line in 3D, but the full 3D line is not within the same distance of the point.
WITH data AS (
SELECT
'POINT(1 1 2)'::geometry AS geom_a,
'LINESTRING(1 5 2,2 7 20,1 9 100,14 12 3)'::geometry AS geom_b
)
SELECT
ST_3DDFullyWithin(geom_a, geom_b, 10) AS d3dfullywithin10,
ST_3DDWithin(geom_a, geom_b, 10) AS d3dwithin10,
ST_DFullyWithin(geom_a, geom_b, 20) AS d2dfullywithin20,
ST_3DDFullyWithin(geom_a, geom_b, 20) AS d3dfullywithin20
FROM data;
d3dfullywithin10 | d3dwithin10 | d2dfullywithin20 | d3dfullywithin20 ------------------+-------------+------------------+------------------ f | t | t | f
ST_DFullyWithin — Testar om en geometri är helt inom ett avstånd från en annan
boolean ST_DFullyWithin(geometry g1, geometry g2, double precision distance);
Returnerar true om g2 är helt inom avståndet från g1. Visuellt är villkoret sant om g2 ligger inom en avståndsbuffert för g1. Avståndet anges i enheter som definieras av geometriernas spatiala referenssystem.
![]() | |
Denna funktion inkluderar automatiskt en jämförelse av begränsningsrutor som använder alla spatiala index som finns tillgängliga för geometrierna. |
Tillgänglighet: 1.5.0
Ändrad: 3.5.0 : logiken bakom funktionen använder nu ett test av inneslutning inom en buffert, snarare än ST_MaxDistance-algoritmen. Resultaten kommer att skilja sig från tidigare versioner, men bör ligga närmare användarnas förväntningar.
SELECT
ST_DFullyWithin(geom_a, geom_b, 10) AS DFullyWithin10,
ST_DWithin(geom_a, geom_b, 10) AS DWithin10,
ST_DFullyWithin(geom_a, geom_b, 20) AS DFullyWithin20
FROM (VALUES
('POINT(1 1)'::geometry, 'LINESTRING(1 5,2 7,1 9,14 12)'::geometry)
) AS v(geom_a, geom_b)dfullywithin10 | dwithin10 | dfullywithin20 ----------------+-----------+---------------- f | t | t
ST_DWithin — Testar om två geometrier ligger inom ett givet avstånd
boolean ST_DWithin(geometry g1, geometry g2, double precision distance_of_srid);
boolean ST_DWithin(geography gg1, geography gg2, double precision distance_meters, boolean use_spheroid = true);
Returnerar true om geometrierna ligger inom ett givet avstånd
För geometri: Avståndet anges i enheter som definieras av geometriernas spatiala referenssystem. För att denna funktion ska vara meningsfull måste källgeometrierna vara i samma koordinatsystem (ha samma SRID).
För geografi: enheterna är i meter och avståndsmätning sker som standard med use_spheroid = true. För snabbare utvärdering, använd use_spheroid = false för att mäta på sfären.
![]() | |
Använd ST_3DDWithin för 3D-geometrier. |
![]() | |
Detta funktionsanrop innehåller en jämförelse av begränsningsrutor som använder alla index som finns tillgängliga för geometrierna. |
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1.
Tillgänglighet: 1.5.0 stöd för geografi infördes
Förbättrad: 2.1.0 förbättrad hastighet för geografi. Se Göra geografi snabbare för mer information.
Förbättrad: 2.1.0 stöd för krökta geometrier infördes.
Före 1.3 användes ST_Expand ofta i kombination med && och ST_Distance för att testa avstånd, och före 1.3.4 använde den här funktionen den logiken. Från och med 1.3.4 använder ST_DWithin en snabbare funktion för kortslutningsavstånd.
This self-contained geometry example keeps the compared shapes visible while also returning the boolean results.
WITH sample AS (
SELECT ST_Buffer('POINT(100 90)'::geometry, 50, 'quad_segs=2') AS coverage,
ST_Point(120, 120) AS inside_pt,
ST_Point(170, 90) AS outside_pt
)
SELECT ST_DWithin(coverage, inside_pt, 0) AS inside_now,
ST_DWithin(coverage, outside_pt, 10) AS outside_within_10,
coverage AS coverage_geom,
inside_pt AS inside_geom,
outside_pt AS outside_geom
FROM sample;-[ RECORD 1 ]----- inside_now | t outside_within_10 | f coverage_geom | POLYGON((150 90,135 55,100 40,65 55,50 90,65 125,100 140,135 125,150 90)) inside_geom | POINT(120 120) outside_geom | POINT(170 90)
Find the nearest hospital to each school. That is within 3000 units of the school. We do an ST_DWithin search to utilize indexes to limit our search list. That the non-indexable ST_Distance needs to process. If the units of the spatial reference is meters then units would be meters.
SELECT DISTINCT ON (s.gid) s.gid, s.school_name, s.geom, h.hospital_name
FROM schools s
LEFT JOIN hospitals h ON ST_DWithin(s.geom, h.geom, 3000)
ORDER BY s.gid, ST_Distance(s.geom, h.geom);
The schools with no close hospitals. Find all schools with no hospital within 3000 units away from the school. Units are in units of spatial reference (for example meters, feet, or degrees).
SELECT s.gid, s.school_name
FROM schools s
LEFT JOIN hospitals h ON ST_DWithin(s.geom, h.geom, 3000)
WHERE h.gid IS NULL;
Find locations more than 3000 units away from their nearest hospital. Use NOT EXISTS so that a location is returned only when no nearby hospital exists.
SELECT l.location_name
FROM locations l
WHERE NOT EXISTS (
SELECT 1
FROM hospitals h
WHERE ST_DWithin(l.geom, h.geom, 3000)
);
Find broadcasting towers that a receiver with limited range can receive. Data is geometry in Spherical Mercator (SRID=3857), ranges are approximate.
CREATE INDEX ON broadcasting_towers USING gist (geom); CREATE INDEX ON broadcasting_towers USING gist (ST_Expand(geom, sending_range));
Query towers that a 4-kilometer receiver in Minsk Hackerspace can get. Note: two conditions are required because the shorter LEAST(b.sending_range, 4000) will not use an index.
SELECT b.tower_id, b.geom
FROM broadcasting_towers b
WHERE ST_DWithin(b.geom, 'SRID=3857;POINT(3072163.4 7159374.1)', 4000)
AND ST_DWithin(b.geom, 'SRID=3857;POINT(3072163.4 7159374.1)', b.sending_range);
ST_PointInsideCircle — Testar om en punktgeometri ligger inom en cirkel definierad av centrum och radie
boolean ST_PointInsideCircle(geometry a_point, float center_x, float center_y, float radius);
Returnerar true om geometrin är en punkt och ligger inom cirkeln med centrum center_x,center_y och radie radius.
![]() | |
Använder inte spatiala index. Använd ST_DWithin istället. |
Tillgänglighet: 1.2
Ändrad: 2.2.0 I tidigare versioner kallades detta ST_Point_Inside_Circle
SELECT ST_PointInsideCircle(ST_Point(1, 2), 0.5, 2, 3);
t
Dessa funktioner beräknar mätningar av avstånd, yta och vinklar. Det finns också funktioner för att beräkna geometriska värden som bestäms av mätningar.
ST_LengthST_Perimeter.ST_Area — Returnerar arean för en polygonal geometri.
float ST_Area(geometry g1);
float ST_Area(geography geog, boolean use_spheroid = true);
Returnerar arean för en polygonal geometri. För geometrityper beräknas en 2D kartesisk (plan) area, med enheter som anges av SRID. För geograftyper bestäms arean som standard på en sfäroid med enheter i kvadratmeter. Om du vill beräkna arean med den snabbare men mindre exakta sfäriska modellen använder du ST_Area(geog,false)..
Förbättrad: 2.0.0 - stöd för 2D polyhedrala ytor infördes.
Förbättrad: 2.2.0 - mätning på sfäroid utförd med GeographicLib för förbättrad noggrannhet och robusthet. Kräver PROJ >= 4.9.0 för att dra nytta av den nya funktionen.
Ändrad: 3.0.0 - är inte längre beroende av SFCGAL.
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 8.1.2, 9.5.3
Denna funktion stöder polyedriska ytor.
![]() | |
För polyedriska ytor stöds endast 2D-polyedriska ytor (inte 2,5D). För 2,5D kan svaret bli något annat än noll, men bara för de ytor som ligger helt i XY-planet. |
Returnera yta i kvadratfot för en tomt i Massachusetts och multiplicera med omvandling för att få kvadratmeter. Observera att detta är i kvadratfot eftersom EPSG:2249 är Massachusetts State Plane Feet
SELECT ST_Area(geom) AS sqft,
ST_Area(geom) * 0.3048 ^ 2 AS sqm
FROM (
SELECT 'SRID=2249;POLYGON((743238 2967416,743238 2967450,
743265 2967450,743265.625 2967416,743238 2967416))'::geometry AS geom
) AS subquery;sqft | sqm --------+------------- 928.625 | 86.27208552
Return area square feet and transform to Massachusetts state plane meters (EPSG:26986) to get square meters. Note this is in square feet because 2249 is Massachusetts State Plane Feet and transformed area is in square meters since EPSG:26986 is state plane Massachusetts meters.
SELECT ST_Area(geom) AS sqft,
round(ST_Area(ST_Transform(geom, 26986))::numeric, 6) AS sqm
FROM (
SELECT 'SRID=2249;POLYGON((743238 2967416,743238 2967450,
743265 2967450,743265.625 2967416,743238 2967416))'::geometry AS geom
) AS subquery;sqft | sqm --------+----------- 928.625 | 86.272431
Returnera area kvadratfot och kvadratmeter med hjälp av datatypen geography. Observera att vi omvandlar vår geometri till geografi (innan du kan göra det måste du se till att din geometri är i WGS 84 long lat 4326). Geografi mäter alltid i meter. Detta är bara för demonstration för att jämföra. Normalt kommer din tabell redan att lagras i datatypen Geography.
SELECT round((ST_Area(geog) / 0.3048 ^ 2)::numeric, 2) AS sqft_spheroid,
round((ST_Area(geog, false) / 0.3048 ^ 2)::numeric, 2) AS sqft_sphere,
round(ST_Area(geog)::numeric, 2) AS sqm_spheroid
FROM (
SELECT ST_Transform(
'SRID=2249;POLYGON((743238 2967416,743238 2967450,
743265 2967450,743265.625 2967416,743238 2967416))'::geometry,
4326
)::geography AS geog
) AS subquery;sqft_spheroid | sqft_sphere | sqm_spheroid
----------------+-------------+--------------
928.68 | 926.61 | 86.28Om dina data redan finns i geografin:
SELECT ST_Area(geog) / 0.3048 ^ 2 AS sqft,
ST_Area(the_geog) AS sqm
FROM somegeogtable;ST_Azimuth — Returnerar den nordbaserade azimuten för en linje mellan två punkter.
float ST_Azimuth(geometry origin, geometry target);
float ST_Azimuth(geography origin, geography target);
Returnerar målpunktens azimut i radianer från ursprungspunkten, eller NULL om de två punkterna sammanfaller. Azimutvinkeln är en positiv medurs vinkel som refereras från den positiva Y-axeln (geometri) eller den norra meridianen (geografi): North = 0; Northeast = π/4; East = π/2; Southeast = 3π/4; South = π; Southwest 5π/4; West = 3π/2; Northwest = 7π/4.
För den geografiska typen är azimutlösningen känd som det inversa geodetiska problemet.
Azimuten är ett matematiskt koncept definierat som vinkeln mellan en referensvektor och en punkt, med vinkelenheter i radianer. Resultatvärdet i radianer kan konverteras till grader med hjälp av PostgreSQL-funktionen grader ()..
For offsetting lines relative to their direction, use ST_OffsetCurve. For projecting a point by distance and bearing, use ST_Project.
Tillgänglighet: 1.1.0
Förbättrad: 2.0.0 stöd för geografi infördes.
Förbättrad: 2.2.0 mätning på sfäroid utförd med GeographicLib för förbättrad noggrannhet och robusthet. Kräver PROJ >= 4.9.0 för att dra nytta av den nya funktionen.
Geometri Azimut i grader
SELECT degrees(ST_Azimuth(ST_Point(25, 45), ST_Point(75, 100))) AS degA_B,
degrees(ST_Azimuth(ST_Point(75, 100), ST_Point(25, 45) )) AS degB_A;dega_b | degb_a ------------------+------------------ 42.27368900609371 | 222.27368900609372
Compass direction labels can be computed from the azimuth.
WITH directions(deg) AS (VALUES
(0), (45), (90), (135), (180), (225), (270), (315)
),
bearings AS (
SELECT deg,
degrees(ST_Azimuth(ST_Point(0, 0),
ST_MakePoint(sin(radians(deg)),
cos(radians(deg))))) AS azimuth
FROM directions
)
SELECT deg,
round(azimuth::numeric, 1) AS azimuth,
(ARRAY['N', 'NE', 'E', 'SE', 'S', 'SW', 'W', 'NW', 'N'])
[floor((azimuth + 22.5) / 45)::int + 1] AS direction
FROM bearings
ORDER BY deg;deg | azimuth | direction -----+---------+----------- 0 | 0.0 | N 45 | 45.0 | NE 90 | 90.0 | E 135 | 135.0 | SE 180 | 180.0 | S 225 | 225.0 | SW 270 | 270.0 | W 315 | 315.0 | NW
Azimuth from Point(25, 45) to Point(75, 100), shown against the positive Y axis (north).
WITH points AS (
SELECT 'POINT(25 45)'::geometry AS origin,
'POINT(75 100)'::geometry AS target
)
SELECT round(degrees(ST_Azimuth(origin, target))::numeric, 6) AS degrees,
ST_MakeLine(origin, ST_Translate(origin, 0, 105)) AS north,
ST_MakeLine(origin, target) AS direction
FROM points;42.273689 | LINESTRING(25 45,25 150) | LINESTRING(25 45,75 100)
Reverse azimuth from Point(75, 100) to Point(25, 45).
WITH points AS (
SELECT 'POINT(75 100)'::geometry AS origin,
'POINT(25 45)'::geometry AS target
)
SELECT round(degrees(ST_Azimuth(origin, target))::numeric, 6) AS degrees,
ST_MakeLine(origin, ST_Translate(origin, 0, 90)) AS north,
ST_MakeLine(origin, target) AS direction
FROM points;222.273689 | LINESTRING(75 100,75 190) | LINESTRING(75 100,25 45)
ST_Angle — Returnerar vinkeln mellan två vektorer som definieras av 3 eller 4 punkter, eller 2 linjer.
float ST_Angle(geometry point1, geometry point2, geometry point3, geometry point4);
float ST_Angle(geometry line1, geometry line2);
Beräknar den medurs vridna vinkeln mellan två vektorer.
Variant 1: beräknar den vinkel som omsluts av punkterna P1-P2-P3. Om en 4:e punkt anges beräknas vinkeln mellan punkterna P1-P2 och P3-P4
Variant 2: beräknar vinkeln mellan två vektorer S1-E1 och S2-E2, definierade av start- och slutpunkterna för indatalinjerna
Resultatet är en positiv vinkel mellan 0 och 2π radianer. Radiansresultatet kan konverteras till grader med hjälp av PostgreSQL-funktionen degrees()..
Observera att ST_Angle(P1,P2,P3) = ST_Angle(P2,P1,P2,P3).
Tillgänglighet: 2.5.0
Vinkel mellan tre punkter
SELECT degrees(ST_Angle('POINT(0 0)', 'POINT(10 10)', 'POINT(20 0)'));270
Vinkel mellan vektorer definierade av fyra punkter
SELECT degrees(ST_Angle('POINT (10 10)', 'POINT (0 0)', 'POINT(90 90)', 'POINT (100 80)'));269.9999999999999
Vinkel mellan vektorer som definieras av linjernas start- och slutpunkter
SELECT degrees(ST_Angle('LINESTRING(0 0,0.3 0.7,1 1)', 'LINESTRING(0 0,0.2 0.5,1 0)'));45
ST_ClosestPoint — Returnerar den 2D-punkt på g1 som ligger närmast g2. Detta är den första punkten på den kortaste linjen från den ena geometrin till den andra.
geometry ST_ClosestPoint(geometry geom1, geometry geom2);
geography ST_ClosestPoint(geography geom1, geography geom2, boolean use_spheroid = true);
Returnerar den 2-dimensionella punkt på geom1 som ligger närmast geom2. Detta är den första punkten på den kortaste linjen mellan geometrierna (enligt beräkning av ST_ShortestLine).
![]() | |
Om du har en 3D-geometri kanske du föredrar att använda ST_3DClosestPoint. |
Förbättrad: 3.4.0 - Stöd för geografi.
Tillgänglighet: 1.5.0
Närmaste punkt för en Point och en LineString är själva punkten. Närmaste punkt för en LineString och en Point är en punkt på linjen.
SELECT ST_ClosestPoint(pt, line) AS cp_pt_line, ST_ClosestPoint(line, pt) AS cp_line_pt
FROM (SELECT 'POINT (160 40)'::geometry AS pt,
'LINESTRING (10 30,50 50,30 110,70 90,180 140,130 190)'::geometry AS line ) AS t;cp_pt_line | cp_line_pt ----------------+------------------------------------------ POINT(160 40) | POINT(125.75342465753425 115.34246575342466)
Find the closest point on polygon A to polygon B.
WITH source AS (
SELECT 'POLYGON ((190 150,20 10,160 70,190 150))'::geometry AS a,
ST_Buffer('POINT(80 160)'::geometry, 30) AS b
)
SELECT b AS polygon_b,
ST_ClosestPoint(a, b) AS closest_point
FROM source;POLYGON((110 160,109.424 154.147,107.716 148.519,104.944 143.333,101.213 138.787,96.667 135.056,91.481 132.284,85.853 130.576,80 130,74.147 130.576,68.519 132.284,63.333 135.056,58.787 138.787,55.056 143.333,52.284 148.519,50.576 154.147,50 160,50.576 165.853,52.284 171.481,55.056 176.667,58.787 181.213,63.333 184.944,68.519 187.716,74.147 189.424,80 190,85.853 189.424,91.481 187.716,96.667 184.944,101.213 181.213,104.944 176.667,107.716 171.481,109.424 165.853,110 160)) | POINT(131.59149149528952 101.89887534906195)
ST_3DClosestPoint — Returnerar den 3D-punkt på g1 som ligger närmast g2. Detta är den första punkten på den kortaste 3D-linjen.
geometry ST_3DClosestPoint(geometry g1, geometry g2);
Returnerar den 3-dimensionella punkt på g1 som ligger närmast g2. Detta är den första punkten på den kortaste 3D-linjen. 3D-längden på den kortaste 3D-linjen är 3D-avståndet.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
Tillgänglighet: 2.0.0
Ändrad: 2.2.0 - om 2 2D-geometrier matas in returneras en 2D-punkt (istället för det gamla beteendet som antog 0 för saknad Z). Vid 2D och 3D antas Z inte längre vara 0 för saknad Z.
Compare the 3D closest point to the 2D closest point for a LineString and a Point.
WITH input AS (
SELECT 'POINT(100 100 30)'::geometry AS pt,
'LINESTRING (20 80 20,98 190 1,110 180 3,50 75 1000)'::geometry AS line
)
SELECT ST_3DClosestPoint(line, pt) AS cp3d_line_pt,
ST_ClosestPoint(line, pt) AS cp2d_line_pt
FROM input;Compare the 3D closest point to the 2D closest point for a LineString and a MultiPoint.
WITH input AS (
SELECT 'MULTIPOINT(100 100 30,50 74 1000)'::geometry AS pt,
'LINESTRING (20 80 20,98 190 1,110 180 3,50 75 900)'::geometry AS line
)
SELECT ST_3DClosestPoint(line, pt) AS cp3d_line_pt,
ST_ClosestPoint(line, pt) AS cp2d_line_pt
FROM input;Compare the 3D closest point to the 2D closest point for a Polygon and a MultiLineString.
WITH input AS (
SELECT ST_GeomFromEWKT(
'POLYGON((175 150 5,20 40 5,35 45 5,50 60 5,100 100 5,175 150 5))'
) AS poly,
ST_GeomFromEWKT(
'MULTILINESTRING((175 155 2,20 40 20,50 60 -2,125 100 1,175 155 1),
(1 10 2,5 20 1))'
) AS mline
)
SELECT ST_3DClosestPoint(poly, mline) AS cp3d,
ST_ClosestPoint(poly, mline) AS cp2d
FROM input;ST_Distance — Returnerar avståndet mellan två geometri- eller geografivärden.
float ST_Distance(geometry g1, geometry g2);
float ST_Distance(geography geog1, geography geog2, boolean use_spheroid = true);
För geometry -typer returneras det minsta kartesiska (plana) 2D-avståndet mellan två geometrier, i projicerade enheter (spatiala ref-enheter).
För geography -typer är standardvärdet att returnera det minsta geodetiska avståndet mellan två geografiska platser i meter, beräkna på den sfäroid som bestäms av SRID. Om use_spheroid är false används en snabbare sfärisk beräkning.
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.23
Denna metod stöder cirkulära strängar och kurvor.
Tillgänglighet: 1.5.0 Stöd för geografi infördes i 1.5. Hastighetsförbättringar för planar för att bättre hantera stora eller många vertexgeometrier
Förbättrad: 2.1.0 förbättrad hastighet för geografi. Se Göra geografi snabbare för mer information.
Förbättrad: 2.1.0 - stöd för krökta geometrier infördes.
Förbättrad: 2.2.0 - mätning på sfäroid utförd med GeographicLib för förbättrad noggrannhet och robusthet. Kräver PROJ >= 4.9.0 för att dra nytta av den nya funktionen.
Ändrad: 3.0.0 - är inte längre beroende av SFCGAL.
Geometriexempel - enheter i plana grader 4326 är WGS 84 long lat, enheter är grader.
SELECT ST_Distance( 'SRID=4326;POINT(-72.1235 42.3521)'::geometry, 'SRID=4326;LINESTRING(-72.1260 42.45,-72.123 42.1546)'::geometry );
0.00150567726382282
Geometriexempel - enheter i meter (SRID: 3857, proportionell mot pixlar på populära webbkartor). Även om värdet är felaktigt kan närliggande värden jämföras korrekt, vilket gör det till ett bra val för algoritmer som KNN eller KMEANS.
SELECT ST_Distance(
ST_Transform('SRID=4326;POINT(-72.1235 42.3521)'::geometry, 3857),
ST_Transform('SRID=4326;LINESTRING(-72.1260 42.45,-72.123 42.1546)'::geometry, 3857) );167.441410065196
Geometriexempel - enheter i meter (SRID: 3857 som ovan, men korrigerad med cos(lat) för att ta hänsyn till distorsion)
SELECT ST_Distance(
ST_Transform('SRID=4326;POINT(-72.1235 42.3521)'::geometry, 3857),
ST_Transform('SRID=4326;LINESTRING(-72.1260 42.45,-72.123 42.1546)'::geometry, 3857)
) * cosd(42.3521);123.742351254151
Geometriexempel - enheter i meter (SRID: 26986 Massachusetts state plane meter) (mest exakt för Massachusetts)
SELECT ST_Distance(
ST_Transform('SRID=4326;POINT(-72.1235 42.3521)'::geometry, 26986),
ST_Transform('SRID=4326;LINESTRING(-72.1260 42.45,-72.123 42.1546)'::geometry, 26986) );123.797937878454
Geometriexempel - enheter i meter (SRID: 2163 US National Atlas Equal area) (minst exakt)
SELECT ST_Distance(
ST_Transform('SRID=4326;POINT(-72.1235 42.3521)'::geometry, 2163),
ST_Transform('SRID=4326;LINESTRING(-72.1260 42.45,-72.123 42.1546)'::geometry, 2163) );126.664256056812
Samma som geometriexemplet men notera enheter i meter - använd sfär för något snabbare och mindre exakta beräkningar.
SELECT ST_Distance(gg1, gg2) As spheroid_dist, ST_Distance(gg1, gg2, false) As sphere_dist
FROM (SELECT
'SRID=4326;POINT(-72.1235 42.3521)'::geography as gg1,
'SRID=4326;LINESTRING(-72.1260 42.45,-72.123 42.1546)'::geography as gg2
) As foo ;spheroid_dist | sphere_dist ------------------+------------------ 123.802076746848 | 123.475736916397
ST_3DDistance — Returnerar det kartesiska 3D-minsta avståndet (baserat på spatial ref) mellan två geometrier i projicerade enheter.
float ST_3DDistance(geometry g1, geometry g2);
Returnerar det 3-dimensionella minsta kartesiska avståndet mellan två geometrier i projicerade enheter (spatiala ref-enheter).
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM ISO/IEC 13249-3
Tillgänglighet: 2.0.0
Ändrad: 2.2.0 - När det gäller 2D och 3D antas Z inte längre vara 0 om Z saknas.
Ändrad: 3.0.0 - SFCGAL-versionen borttagen
Geometry example - units in meters (SRID: 2163 US National Atlas Equal area) (3D point and line compared 2D point and line) Note that currently no vertical datum support so Z is not transformed and assumed to be same units as final.
SELECT ST_3DDistance(
ST_Transform('SRID=4326;POINT(-72.1235 42.3521 4)'::geometry, 2163),
ST_Transform('SRID=4326;LINESTRING(-72.1260 42.45 15,-72.123 42.1546 20)'::geometry, 2163)
) As dist_3d,
ST_Distance(
ST_Transform('SRID=4326;POINT(-72.1235 42.3521)'::geometry, 2163),
ST_Transform('SRID=4326;LINESTRING(-72.1260 42.45,-72.123 42.1546)'::geometry, 2163)
) As dist_2d;dist_3d | dist_2d ------------------+----------------- 127.295059324629 | 126.66425605671
Multilinestring and polygon both 3D and 2D distance. Same example as 3D closest point example.
SELECT ST_3DDistance(poly, mline) As dist3d,
ST_Distance(poly, mline) As dist2d
FROM (SELECT 'POLYGON((175 150 5,20 40 5,35 45 5,50 60 5,100 100 5,175 150 5))'::geometry as poly,
'MULTILINESTRING((175 155 2,20 40 20,50 60 -2,125 100 1,175 155 1),(1 10 2,5 20 1))'::geometry as mline) as foo;dist3d | dist2d
-------------------+--------
0 | 0ST_DistanceSphere — Returnerar minsta avstånd i meter mellan två lon/lat-geometrier med hjälp av en sfärisk jordmodell.
float ST_DistanceSphere(geometry geomlonlatA, geometry geomlonlatB, float8 radius=6371008);
Returnerar minsta avstånd i meter mellan två lon/lat-punkter. Använder en sfärisk jord och en radie som härrör från den sfäroid som definieras av SRID. Snabbare än ST_DistanceSpheroid, men mindre exakt. PostGIS-versioner före 1.5 implementeras endast för punkter.
Tillgänglighet: 1.5 - stöd för andra geometrityper än punkter infördes. Tidigare versioner fungerar bara med punkter.
Ändrad: 2.2.0 I tidigare versioner brukade detta kallas ST_Distance_Sphere
WITH sample AS (
SELECT
ST_GeomFromText('LINESTRING(-118.584 38.374,-118.583 38.5)', 4326) AS geom,
ST_GeomFromText('POINT(-118 38)', 4326) AS pt
)
SELECT
round(ST_DistanceSphere(ST_Centroid(geom), pt)::numeric, 2) AS dist_meters,
round(ST_Distance(
ST_Transform(ST_Centroid(geom), 32611),
ST_Transform(pt, 32611)
)::numeric, 2) AS dist_utm11_meters,
round(ST_Distance(ST_Centroid(geom), pt)::numeric, 5) AS dist_degrees,
round(ST_Distance(
ST_Transform(geom, 32611),
ST_Transform(pt, 32611)
)::numeric, 2) AS min_dist_line_point_meters
FROM sample;dist_meters | dist_utm11_meters | dist_degrees | min_dist_line_point_meters
-------------+-------------------+--------------+----------------------------
70424.71 | 70438.00 | 0.72900 | 65871.18ST_DistanceSpheroid — Returnerar det minsta avståndet mellan två lon/lat-geometrier med hjälp av en sfäroid jordmodell.
float ST_DistanceSpheroid(geometry geomlonlatA, geometry geomlonlatB, spheroid measurement_spheroid=WGS84);
Returnerar minsta avstånd i meter mellan två lon/lat-geometrier givet en viss sfäroid. Se förklaringen av sfäroider som ges för ST_LengthSpheroid.
![]() | |
Denna funktion tittar inte på geometrins SRID. Den förutsätter att geometrins koordinater är baserade på den angivna sfäroiden. |
Tillgänglighet: 1.5 - stöd för andra geometrityper än punkter infördes. Tidigare versioner fungerar bara med punkter.
Ändrad: 2.2.0 I tidigare versioner kallades detta ST_Distance_Spheroid
WITH input AS (
SELECT ST_Centroid(
ST_GeomFromText(
'LINESTRING(-118.584 38.374,-118.583 38.5)', 4326
)
) AS source,
ST_GeomFromText('POINT(-118 38)', 4326) AS target
)
SELECT round(
ST_DistanceSpheroid(
source,
target,
'SPHEROID["WGS 84",6378137,298.257223563]'
)::numeric,
2
) AS dist_meters_spheroid,
round(ST_DistanceSphere(source, target)::numeric, 2)
AS dist_meters_sphere,
round(
ST_Distance(
ST_Transform(source, 32611),
ST_Transform(target, 32611)
)::numeric,
2
) AS dist_utm11_meters
FROM input;dist_meters_spheroid | dist_meters_sphere | dist_utm11_meters
----------------------+--------------------+-------------------
70454.92 | 70424.71 | 70438.00ST_FrechetDistance — Returnerar Fréchet-avståndet mellan två geometrier.
float ST_FrechetDistance(geometry g1, geometry g2, float densifyFrac = -1);
Implementerar algoritm för att beräkna Fréchet-avståndet begränsat till diskreta punkter för båda geometrierna, baserat på Computing Discrete Fréchet Distance. Fréchet-avståndet är ett mått på likhet mellan kurvor som tar hänsyn till placeringen och ordningsföljden av punkterna längs kurvorna. Därför är det ofta bättre än Hausdorff-avståndet.
När det valfria alternativet densifyFrac anges utför denna funktion en segmentförtätning innan det diskreta Fréchet-avståndet beräknas. Parametern densifyFrac anger den fraktion som varje segment ska förtätas med. Varje segment kommer att delas upp i ett antal lika långa undersegment, vars fraktion av den totala längden är närmast den angivna fraktionen.
Enheterna är i enheterna i geometriernas spatiala referenssystem.
![]() | |
Den nuvarande implementationen stöder endast toppar som diskreta platser. Detta kan utökas så att en godtycklig täthet av punkter kan användas. |
![]() | |
Ju mindre densifyFrac vi anger, desto mer exakt Fréchet-avstånd får vi. Men beräkningstiden och minnesanvändningen ökar med kvadraten på antalet delsegment. |
Utförs av GEOS-modulen.
Tillgänglighet: 2.4.0 - kräver GEOS >= 3.7.0
Both lines are traversed from left to right. The first line is straight, while the second bows upward through its middle vertex. The point ordering matters, so keeping both inputs in the same direction makes the comparison clearer.
WITH lines AS (
SELECT 'LINESTRING (0 0,100 0)'::geometry AS baseline,
'LINESTRING (0 0,50 50,100 0)'::geometry AS bowed
)
SELECT baseline AS baseline,
bowed AS bowed,
ST_FrechetDistance(baseline, bowed) AS discrete_distance,
ST_FrechetDistance(baseline, bowed, 0.5) AS densified_distance
FROM lines;ST_HausdorffDistance — Returnerar Hausdorff-avståndet mellan två geometrier.
float ST_HausdorffDistance(geometry g1, geometry g2);
float ST_HausdorffDistance(geometry g1, geometry g2, float densifyFrac);
Returnerar Hausdorff-avståndet mellan två geometrier. Hausdorff-avståndet är ett mått på hur lika eller olika två geometrier är.
Funktionen beräknar faktiskt det "diskreta Hausdorff-avståndet". Detta är Hausdorff-avståndet som beräknas vid diskreta punkter på geometrierna. Parametern densifyFrac kan specificeras för att ge ett mer exakt svar genom att segmenten förtätas innan det diskreta Hausdorff-avståndet beräknas. Varje segment delas upp i ett antal lika långa undersegment vars fraktion av segmentlängden ligger närmast den givna fraktionen.
Enheterna är i enheterna i geometriernas spatiala referenssystem.
![]() | |
Den här algoritmen är INTE likvärdig med standardavståndet Hausdorff. Den beräknar dock en approximation som är korrekt för en stor delmängd av användbara fall. Ett viktigt fall är linjesträngar som är ungefär parallella med varandra och ungefär lika långa. Detta är ett användbart mått för linjematchning. |
Tillgänglighet: 1.5.0
Hausdorff distance and minimum distance between two lines. The Hausdorff witness segment from the original illustration is retained and its length is checked against the computed distance.
WITH lines AS (
SELECT 'LINESTRING (20 70,70 60,110 70,170 70)'::geometry AS geomA,
'LINESTRING (20 90,130 90,60 100,190 100)'::geometry AS geomB,
'LINESTRING (52.69230769230769 63.46153846153846,60 100)'::geometry AS hausdorff_segment
)
SELECT round(ST_HausdorffDistance(geomA, geomB)::numeric, 6) AS hausdorff_distance,
round(ST_Distance(geomA, geomB)::numeric, 6) AS distance,
round(ST_Length(hausdorff_segment)::numeric, 6) AS witness_length,
ST_ShortestLine(geomA, geomB) AS distance_segment
FROM lines;37.262066 | 20.000000 | 37.262066 | LINESTRING(20 70,20 90)
Exempel: Hausdorff-avstånd med förtätning.
SELECT ST_HausdorffDistance(
'LINESTRING (130 0,0 0,0 150)'::geometry,
'LINESTRING (10 10,10 150,130 10)'::geometry,
0.5);70
Exempel: För varje byggnad, hitta den tomt som bäst representerar den. Först krävs att tomten korsar byggnadens geometri. DISTINCT ON garanterar att varje byggnad bara listas en gång. ORDER BY .. ST_HausdorffDistance väljer det skifte som är mest likt byggnaden.
SELECT DISTINCT ON (buildings.gid) buildings.gid, parcels.parcel_id
FROM buildings
INNER JOIN parcels
ON ST_Intersects(buildings.geom, parcels.geom)
ORDER BY buildings.gid, ST_HausdorffDistance(buildings.geom, parcels.geom);
ST_Length — Returnerar 2D-längden för en linjär geometri.
float ST_Length(geometry a_2dlinestring);
float ST_Length(geography geog, boolean use_spheroid = true);
För geometrityper: returnerar geometrins kartesiska 2D-längd om det är en LineString, MultiLineString, ST_Curve, ST_MultiCurve. För arealgeometrier returneras 0; använd ST_Perimeter i stället. Längdenheterna bestäms av geometrins spatiala referenssystem.
For geography types: computation is performed using the inverse geodesic calculation. Units of length are in meters. The spheroid is specified by the SRID; when no SRID is provided, WGS84 is used. If use_spheroid = false, then the calculation is based on a sphere instead of a spheroid.
För geometri är detta för närvarande ett alias för ST_Length2D, men detta kan ändras för att stödja högre dimensioner.
Ändrad: 2.0.0 Genomgripande ändring - i tidigare versioner gav en tillämpning av detta på en MULTI/POLYGON av typen geografi omkretsen av POLYGONEN/MULTIPOLYGONEN. I 2.0.0 ändrades detta till att returnera 0 för att vara i linje med geometrins beteende. Använd ST_Perimeter om du vill ha omkretsen av en polygon
![]() | |
För geografi använder beräkningen som standard en sfäroid modell. Om du vill använda den snabbare men mindre exakta sfäriska beräkningen använder du ST_Length(gg,false); |
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s2.1.5.1
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 7.1.2, 9.3.4
Tillgänglighet: 1.5.0 Stöd för geografi infördes i 1.5.
Returnerar längd i fot för radsträng. Observera att detta är i fot eftersom EPSG:2249 är Massachusetts State Plane Feet
SELECT ST_Length(ST_GeomFromText( 'LINESTRING(743238 2967416,743238 2967450,743265 2967450, 743265.625 2967416,743238 2967416)', 2249));
122.63074400009504
This example transforms a WGS 84 LineString to Massachusetts State Plane meters.
SELECT ST_Length(ST_Transform(
'SRID=4326;LINESTRING(-72.1260 42.45,-72.1240 42.45666,-72.123 42.1546)'::geometry,
26986
)
);34309.4563576191
Returnera längden på WGS 84-geografilinjen
This example uses the default spheroid calculation.
SELECT ST_Length(the_geog) As length_spheroid, ST_Length(the_geog, false) As length_sphere
FROM (SELECT ST_GeographyFromText('SRID=4326;LINESTRING(-72.1260 42.45,-72.1240 42.45666,-72.123 42.1546)') As the_geog)
As foo;length_spheroid | length_sphere ------------------+------------------ 34310.5703627284 | 34346.20609607416
ST_Length2D — Returnerar 2D-längden för en linjär geometri. Alias för ST_Length
float ST_Length2D(geometry a_2dlinestring);
Returnerar geometrins 2D-längd om det är en linestrings eller multilinestrings. Detta är ett alias för ST_Length
ST_3DLength — Returnerar 3D-längden för en linjär geometri.
float ST_3DLength(geometry a_3dlinestring);
Returnerar den 3-dimensionella eller 2-dimensionella längden på geometrin om det är en LineString eller MultiLineString. För 2-d linjer returneras bara 2-d längden (samma som ST_Length och ST_Length2D)
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM IEC 13249-3: 7.1, 10.3
Ändrad: 2.0.0 I tidigare versioner brukade detta kallas ST_Length3D
Returlängd i fot för en 3D-kabel. Observera att detta är i fot eftersom EPSG:2249 är Massachusetts State Plane Feet
SELECT ST_3DLength(ST_GeomFromText( 'LINESTRING(743238 2967416 1,743238 2967450 1,743265 2967450 3, 743265.625 2967416 3,743238 2967416 3)', 2249));
122.70471674145682
ST_LengthSpheroid — Returnerar 2D- eller 3D-längd/perimeter för en lon/lat-geometri på en sfäroid.
float ST_LengthSpheroid(geometry a_geometry, spheroid a_spheroid);
Calculates the length or perimeter of a geometry on a spheroid. This is useful if the coordinates of the geometry are in longitude/latitude and a length is desired without reprojection. The spheroid is specified by a text value as follows:
SPHEROID[<NAME>,<SEMI-MAJOR AXIS>,<INVERSE FLATTENING>]
Till exempel:
SPHEROID["GRS_1980",6378137,298.257222101]
Tillgänglighet: 1.2.2
Ändrad: 2.2.0 I tidigare versioner kallades detta ST_Length_Spheroid och hade aliaset ST_3DLength_Spheroid
Denna funktion stöder 3d och kommer inte att tappa z-index.
Measure a table geometry directly on a spheroid when the coordinates are stored in longitude and latitude.
SELECT ST_LengthSpheroid(
geometry_column,
'SPHEROID["GRS_1980",6378137,298.257222101]'
)
FROM geometry_table;This example measures a 2D MultiLineString and each component separately on the same spheroid.
WITH sample AS (
SELECT 'MULTILINESTRING((-118.584 38.374,-118.583 38.5),
(-71.05957 42.3589,-71.061 43))'::geometry AS geom,
CAST('SPHEROID["GRS_1980",6378137,298.257222101]' AS spheroid) AS sph_m
)
SELECT ST_LengthSpheroid(geom, sph_m) AS tot_len,
ST_LengthSpheroid(ST_GeometryN(geom, 1), sph_m) AS len_line1,
ST_LengthSpheroid(ST_GeometryN(geom, 2), sph_m) AS len_line2
FROM sample;tot_len | len_line1 | len_line2 ------------------+------------------+------------------ 85204.52077117894 | 13986.87252824332 | 71217.64824293563
This example uses 3D input; Z contributes to the measured result.
WITH sample AS (
SELECT 'MULTILINESTRING((-118.584 38.374 20,-118.583 38.5 30),
(-71.05957 42.3589 75,-71.061 43 90))'::geometry AS geom,
CAST('SPHEROID["GRS_1980",6378137,298.257222101]' AS spheroid) AS sph_m
)
SELECT ST_LengthSpheroid(geom, sph_m) AS tot_len,
ST_LengthSpheroid(ST_GeometryN(geom, 1), sph_m) AS len_line1,
ST_LengthSpheroid(ST_GeometryN(geom, 2), sph_m) AS len_line2
FROM sample;tot_len | len_line1 | len_line2 ------------------+-----------------+------------------ 85204.52592562366 | 13986.876103023424 | 71217.64982260024
ST_LongestLine — Returnerar den längsta 2D-linjen mellan två geometrier.
geometry ST_LongestLine(geometry g);
geometry ST_LongestLine(geometry g1, geometry g2);
Returnerar den 2-dimensionella längsta linjen mellan punkterna i två geometrier. Linjen som returneras börjar på g1 och slutar på g2.
Den längsta linjen finns alltid mellan två hörn. Funktionen returnerar den första längsta linjen om mer än en hittas. Linjens längd är lika med det avstånd som returneras av ST_MaxDistance.
If only one geometry is provided, or g1 and g2 are the same geometry, returns the line between the two vertices farthest apart in the geometry. The endpoints of the line lie on the circle computed by ST_MinimumBoundingCircle.
Tillgänglighet: 1.5.0
Enhanced: 3.7.0 - support for a single geometry input.
Longest line between a Point and a LineString.
SELECT ST_LongestLine(
'POINT (160 40)',
'LINESTRING (10 30,50 50,30 110,70 90,180 140,130 190)' ) AS lline;LINESTRING(160 40,130 190)
Longest line between two polygons.
SELECT ST_LongestLine(
'POLYGON ((190 150,20 10,160 70,190 150))',
ST_Buffer('POINT(80 160)', 30)
) AS llinewkt;LINESTRING(20 10,91.4805029709527 187.7163859753386)
Längsta linjen över en enda geometri. Linjens längd är lika med det maximala avståndet. Linjens ändpunkter ligger på den minsta begränsningscirkeln.
SELECT ST_LongestLine(geom) AS llinewkt,
ST_MaxDistance(geom) AS max_dist,
ST_Length(ST_LongestLine(geom)) AS lenll
FROM (SELECT 'POLYGON ((40 180,110 160,180 180,180 120,140 90,160 40,80 10,70 40,20 50,40 180),
(60 140,99 77.5,90 140,60 140))'::geometry AS geom) AS t;llinewkt | max_dist | lenll ---------------------------+--------------------+-------------------- LINESTRING(20 50,180 180) | 206.15528128088303 | 206.15528128088303
ST_3DLongestLine — Returnerar den längsta 3D-linjen mellan två geometrier
geometry ST_3DLongestLine(geometry g1, geometry g2);
Returnerar den 3-dimensionella längsta linjen mellan två geometrier. Funktionen returnerar den första längsta linjen om det finns fler än en. Linjen som returneras börjar i g1 och slutar i g2. Linjens 3D-längd är lika med det avstånd som returneras av ST_3DMaxDistance.
Tillgänglighet: 2.0.0
Ändrad: 2.2.0 - om 2 2D-geometrier matas in returneras en 2D-punkt (istället för det gamla beteendet som antog 0 för saknad Z). Vid 2D och 3D antas Z inte längre vara 0 för saknad Z.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
Longest line between a LineString and a Point, comparing the 3D and 2D results.
SELECT ST_3DLongestLine(line, pt) AS lol3d_line_pt, ST_LongestLine(line, pt) AS lol2d_line_pt
FROM (
SELECT 'POINT(100 100 30)'::geometry AS pt,
'LINESTRING (20 80 20,98 190 1,110 180 3,50 75 1000)'::geometry AS line
) AS foo;lol3d_line_pt | lol2d_line_pt -----------------------------------+---------------------------- LINESTRING(50 75 1000,100 100 30) | LINESTRING(98 190,100 100)
Longest line between a LineString and a MultiPoint, comparing the 3D and 2D results.
SELECT ST_3DLongestLine(line, pt) AS lol3d_line_pt, ST_LongestLine(line, pt) AS lol2d_line_pt
FROM (
SELECT 'MULTIPOINT(100 100 30,50 74 1000)'::geometry AS pt,
'LINESTRING (20 80 20,98 190 1,110 180 3,50 75 900)'::geometry AS line
) AS foo;lol3d_line_pt | lol2d_line_pt ---------------------------------+-------------------------- LINESTRING(98 190 1,50 74 1000) | LINESTRING(98 190,50 74)
Longest line between a Polygon and a MultiLineString, comparing the 3D and 2D results.
SELECT ST_3DLongestLine(poly, mline) AS lol3d, ST_LongestLine(poly, mline) AS lol2d
FROM (
SELECT ST_GeomFromEWKT(
'POLYGON((175 150 5,20 40 5,35 45 5,50 60 5,100 100 5,175 150 5))'
) AS poly,
ST_GeomFromEWKT(
'MULTILINESTRING((175 155 2,20 40 20,50 60 -2,125 100 1,175 155 1),
(1 10 2,5 20 1))'
) AS mline
) AS foo;lol3d | lol2d ------------------------------+-------------------------- LINESTRING(175 150 5,1 10 2) | LINESTRING(175 150,1 10)
ST_MaxDistance — Returnerar det största 2D-avståndet mellan två geometrier i projicerade enheter.
float ST_MaxDistance(geometry g);
float ST_MaxDistance(geometry g1, geometry g2);
Returnerar det 2-dimensionella maximala avståndet mellan två geometrier, i projicerade enheter. Det maximala avståndet inträffar alltid mellan två hörn. Detta är längden på den linje som returneras av ST_LongestLine.
If only one geometry is provided, or g1 and g2 are the same geometry, returns the distance between the two vertices farthest apart in that geometry.
Tillgänglighet: 1.5.0
Enhanced: 3.7.0 - support for a single geometry input.
Maximalt avstånd mellan en punkt och linjer.
SELECT ST_MaxDistance('POINT(0 0)'::geometry, 'LINESTRING ( 2 0,0 2 )'::geometry);2
SELECT ST_MaxDistance('POINT(0 0)'::geometry, 'LINESTRING ( 2 2,2 2 )'::geometry);2.82842712474619
Maximalt avstånd mellan hörnpunkter i en och samma geometri.
SELECT ST_MaxDistance('POLYGON ((10 10,10 0,0 0,10 10))'::geometry);14.142135623730951
ST_3DMaxDistance — Returnerar det maximala kartesiska 3D-avståndet (baserat på spatial ref) mellan två geometrier i projicerade enheter.
float ST_3DMaxDistance(geometry g1, geometry g2);
Returnerar det 3-dimensionella maximala cartesiska avståndet mellan två geometrier i projicerade enheter (spatiala ref-enheter).
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
Tillgänglighet: 2.0.0
Ändrad: 2.2.0 - När det gäller 2D och 3D antas Z inte längre vara 0 om Z saknas.
Geometry example - units in meters (SRID: 2163 US National Atlas Equal area) (3D point and line compared 2D point and line) Note that currently no vertical datum support so Z is not transformed and assumed to be same units as final.
SELECT ST_3DMaxDistance(
ST_Transform('SRID=4326;POINT(-72.1235 42.3521 10000)'::geometry, 2163),
ST_Transform('SRID=4326;LINESTRING(-72.1260 42.45 15,-72.123 42.1546 20)'::geometry, 2163)
) As dist_3d,
ST_MaxDistance(
ST_Transform('SRID=4326;POINT(-72.1235 42.3521 10000)'::geometry, 2163),
ST_Transform('SRID=4326;LINESTRING(-72.1260 42.45 15,-72.123 42.1546 20)'::geometry, 2163)
) As dist_2d;dist_3d | dist_2d ------------------+------------------ 24383.7467488441 | 22247.8472107251
ST_MinimumClearance — Returnerar den minsta frigången för en geometri, ett mått på geometrins robusthet.
float ST_MinimumClearance(geometry g);
Det är möjligt att en geometri uppfyller kriterierna för giltighet enligt ST_IsValid (polygoner) eller ST_IsSimple (linjer), men att den blir ogiltig om en av dess hörnpunkter flyttas ett litet avstånd. Detta kan ske på grund av förlust av precision vid konvertering till textformat (t.ex. WKT, KML, GML, GeoJSON) eller binära format som inte använder koordinater med dubbel precision och flyttal (t.ex. MapInfo TAB).
Det minsta avståndet är ett kvantitativt mått på en geometris robusthet mot förändringar i koordinatprecisionen. Det är det största avstånd med vilket geometrins hörn kan flyttas utan att skapa en ogiltig geometri. Större värden på minsta avstånd indikerar större robusthet.
Om en geometri har en minsta frihöjd på e, då:
Inga två distinkta hörn i geometrin ligger närmare varandra än avståndet e.
Ingen toppunkt är närmare än e ett linjesegment där den inte är en ändpunkt.
Om det inte finns något minsta spelrum för en geometri (t.ex. en enskild punkt eller en MultiPoint vars punkter är identiska), är returvärdet Infinity.
För att undvika validitetsproblem som orsakas av precisionsförlust kan ST_ReducePrecision minska koordinatprecisionen samtidigt som polygongeometrin förblir giltig.
Tillgänglighet: 2.3.0
SELECT ST_MinimumClearance('POLYGON ((0 0,1 0,1 1,0.5 3.2e-4,0 0))');0.00032
ST_MinimumClearanceLine — Returnerar LineString med två punkter som sträcker sig över en geometris minsta spelrum.
Geometry ST_MinimumClearanceLine(geometry g);
Returnerar den tvåpunkts LineString som sträcker sig över en geometris minsta spelrum. Om geometrin inte har något minsta spelrum returneras LINESTRING EMPTY.
Utförs av GEOS-modulen.
Tillgänglighet: 2.3.0 - kräver GEOS >= 3.6.0
SELECT ST_MinimumClearanceLine('POLYGON ((0 0,1 0,1 1,0.5 3.2e-4,0 0))');LINESTRING(0.5 0.00032,0.5 0)
ST_Perimeter — Returnerar längden på gränsen för en polygonal geometri eller geografi.
float ST_Perimeter(geometry g1);
float ST_Perimeter(geography geog, boolean use_spheroid = true);
Returnerar 2D-perimetern för geometrin/geografin om den är en ST_Surface, ST_MultiSurface (Polygon, MultiPolygon). 0 returneras för icke-verkliga geometrier. För linjära geometrier används ST_Length. För geometrityper specificeras enheter för perimetermått av geometrins spatiala referenssystem.
For geography types, the calculations are performed using the inverse geodesic problem, where perimeter units are in meters. The spheroid is specified by the SRID; when no SRID is provided, WGS84 is used. If use_spheroid = false, then calculations will approximate a sphere instead of a spheroid.
För närvarande är detta ett alias för ST_Perimeter2D, men detta kan ändras för att stödja högre dimensioner.
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s2.1.5.1
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 8.1.3, 9.5.4
Tillgänglighet 2.0.0: Stöd för geografi infördes
Geometry.
Returnerar omkrets i fot för Polygon och MultiPolygon. Observera att detta är i fot eftersom EPSG:2249 är Massachusetts State Plane Feet
SELECT ST_Perimeter(ST_GeomFromText( 'POLYGON((743238 2967416,743238 2967450,743265 2967450, 743265.625 2967416,743238 2967416))', 2249));
122.63074400009504
SELECT ST_Perimeter(ST_GeomFromText( 'MULTIPOLYGON(((763104.471273676 2949418.44119003, 763104.477769673 2949418.42538203, 763104.189609677 2949418.22343004,763104.471273676 2949418.44119003)), ((763104.471273676 2949418.44119003,763095.804579742 2949436.33850239, 763086.132105649 2949451.46730207,763078.452329651 2949462.11549407, 763075.354136904 2949466.17407812,763064.362142565 2949477.64291974, 763059.953961626 2949481.28983009,762994.637609571 2949532.04103014, 762990.568508415 2949535.06640477,762986.710889563 2949539.61421415, 763117.237897679 2949709.50493431,763235.236617789 2949617.95619822, 763287.718121842 2949562.20592617,763111.553321674 2949423.91664605, 763104.471273676 2949418.44119003)))', 2249));
845.227713366825
Returnerar omkrets i meter och fot för Polygon och MultiPolygon. Observera att detta är geografi (WGS 84 long lat)
SELECT ST_Perimeter(geog) As per_meters, ST_Perimeter(geog)/0.3048 As per_ft
FROM ST_GeogFromText('POLYGON((-71.1776848522251 42.3902896512902,-71.1776843766326 42.3903829478009,
-71.1775844305465 42.3903826677917,-71.1775825927231 42.3902893647987,-71.1776848522251 42.3902896512902))') As geog;per_meters | per_ft -----------------+------------------ 37.37904625414049 | 122.63466618812497
This example uses a MultiPolygon.
SELECT ST_Perimeter(geog) As per_meters, ST_Perimeter(geog, false) As per_sphere_meters, ST_Perimeter(geog)/0.3048 As per_ft
FROM ST_GeogFromText('MULTIPOLYGON(((-71.1044543107478 42.340674480411,-71.1044542869917 42.3406744369506,
-71.1044553562977 42.340673886454,-71.1044543107478 42.340674480411)),
((-71.1044543107478 42.340674480411,-71.1044860600303 42.3407237015564,-71.1045215770124 42.3407653385914,
-71.1045498002983 42.3407946553165,-71.1045611902745 42.3408058316308,-71.1046016507427 42.340837442371,
-71.104617893173 42.3408475056957,-71.1048586153981 42.3409875993595,-71.1048736143677 42.3409959528211,
-71.1048878050242 42.3410084812078,-71.1044020965803 42.3414730072048,
-71.1039672113619 42.3412202916693,-71.1037740497748 42.3410666421308,
-71.1044280218456 42.3406894151355,-71.1044543107478 42.340674480411)))') As geog;per_meters | per_sphere_meters | per_ft
------------------+-------------------+------------------
257.634283683311 | 257.412311446337 | 845.256836231335
ST_Perimeter2D — Returnerar 2D-perimetern för en polygonal geometri. Alias för ST_Perimeter.
float ST_Perimeter2D(geometry geomA);
Returnerar den 2-dimensionella omkretsen för en polygonal geometri.
![]() | |
Detta är för närvarande ett alias för ST_Perimeter. I framtida versioner kan ST_Perimeter returnera den högsta dimensionens omkrets för en geometri. Detta är fortfarande under övervägande |
ST_3DPerimeter — Returnerar 3D-perimetern för en polygonal geometri.
float ST_3DPerimeter(geometry geomA);
Returnerar geometrins 3-dimensionella omkrets, om den är en polygon eller multipolygon. Om geometrin är 2-dimensionell returneras den 2-dimensionella omkretsen.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM ISO/IEC 13249-3: 8.1, 10.5
Ändrad: 2.0.0 I tidigare versioner brukade detta kallas ST_Perimeter3D
Omkretsen av en något upphöjd polygon i luften i Massachusetts state plan feet
SELECT ST_3DPerimeter(geom), ST_Perimeter2D(geom), ST_Perimeter(geom) FROM
(SELECT 'SRID=2249;POLYGON((743238 2967416 2,743238 2967450 1,
743265.625 2967416 1,743238 2967416 2))'::geometry As geom) As foo;ST_3DPerimeter | st_perimeter2d | st_perimeter ------------------+------------------+------------------ 105.46579359767418 | 105.43299727218763 | 105.43299727218763
ST_ShortestLine — Returnerar den kortaste 2D-linjen mellan två geometrier
geometry ST_ShortestLine(geometry geom1, geometry geom2);
geography ST_ShortestLine(geography geom1, geography geom2, boolean use_spheroid = true);
Returnerar den 2-dimensionella kortaste linjen mellan två geometrier. Den returnerade linjen börjar i geom1 och slutar i geom2. Om geom1 och geom2 skär varandra blir resultatet en linje med start och slut i en skärningspunkt. Linjens längd är densamma som ST_Distance returnerar för g1 och g2.
Förbättrad: 3.4.0 - stöd för geografi.
Tillgänglighet: 1.5.0
Shortest line between a Point and a LineString.
SELECT ST_ShortestLine(
'POINT (160 40)',
'LINESTRING (10 30,50 50,30 110,70 90,180 140,130 190)') As sline;LINESTRING(160 40,125.75342465753425 115.34246575342466)
Shortest line between polygons.
SELECT ST_ShortestLine(
'POLYGON ((190 150,20 10,160 70,190 150))',
ST_Buffer('POINT(80 160)', 30)
) AS llinewkt;LINESTRING(131.59149149528952 101.89887534906195,101.21320343559643 138.78679656440357)
ST_3DShortestLine — Returnerar den kortaste 3D-linjen mellan två geometrier
geometry ST_3DShortestLine(geometry g1, geometry g2);
Returnerar den 3-dimensionella kortaste linjen mellan två geometrier. Funktionen returnerar endast den första kortaste linjen om det finns fler än en som funktionen hittar. Om g1 och g2 skär varandra i endast en punkt returnerar funktionen en linje med både start och slut i den skärningspunkten. Om g1 och g2 skär varandra i mer än en punkt kommer funktionen att returnera en linje med start och slut i samma punkt, men det kan vara vilken som helst av de skärande punkterna. Linjen som returneras börjar alltid i g1 och slutar i g2. 3D-längden på linjen som denna funktion returnerar kommer alltid att vara densamma som ST_3DDistance returnerar för g1 och g2.
Tillgänglighet: 2.0.0
Ändrad: 2.2.0 - om 2 2D-geometrier matas in returneras en 2D-punkt (istället för det gamla beteendet som antog 0 för saknad Z). Vid 2D och 3D antas Z inte längre vara 0 för saknad Z.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
Compare the 3D shortest line to the 2D shortest line for a LineString and a Point.
WITH input AS (
SELECT 'POINT(100 100 30)'::geometry AS pt,
'LINESTRING (20 80 20,98 190 1,110 180 3,50 75 1000)'::geometry AS line
)
SELECT ST_3DShortestLine(line, pt) AS shl3d_line_pt,
ST_ShortestLine(line, pt) AS shl2d_line_pt
FROM input;Compare the 3D shortest line to the 2D shortest line for a LineString and a MultiPoint.
WITH input AS (
SELECT 'MULTIPOINT(100 100 30,50 74 1000)'::geometry AS pt,
'LINESTRING (20 80 20,98 190 1,110 180 3,50 75 900)'::geometry AS line
)
SELECT ST_3DShortestLine(line, pt) AS shl3d_line_pt,
ST_ShortestLine(line, pt) AS shl2d_line_pt
FROM input;Compare the 3D shortest line to the 2D shortest line for a Polygon and a MultiLineString.
WITH input AS (
SELECT ST_GeomFromEWKT(
'POLYGON((175 150 5,20 40 5,35 45 5,50 60 5,100 100 5,175 150 5))'
) AS poly,
ST_GeomFromEWKT(
'MULTILINESTRING((175 155 2,20 40 20,50 60 -2,125 100 1,175 155 1),
(1 10 2,5 20 1))'
) AS mline
)
SELECT ST_3DShortestLine(poly, mline) AS shl3d,
ST_ShortestLine(poly, mline) AS shl2d
FROM input;Dessa funktioner beräknar resultat som uppstår vid överlagring av två geometrier. Dessa kallas också för punktuppsättningsteoretiska booleska operationer. Vissa relaterade funktioner tillhandahålls också.
ST_ClipByBox2D — Beräknar den del av en geometri som faller inom en rektangel.
geometry ST_ClipByBox2D(geometry geom, box2d box);
Klipper en geometri med en 2D-box på ett snabbt och tolerant men eventuellt ogiltigt sätt. Topologiskt ogiltiga indatageometrier resulterar inte i att undantag kastas. Det är inte garanterat att utdatageometrin är giltig (i synnerhet kan självskärningar för en polygon introduceras).
Utförs av GEOS-modulen.
Tillgänglighet: 2.2.0
This example relies on the implicit cast from geometry to box2d for the second parameter.
SELECT ST_ClipByBox2D(geom, ST_MakeEnvelope(0, 0, 10, 10)) FROM mytab;
ST_Difference — Beräknar en geometri som representerar den del av geometri A som inte skär geometri B.
geometry ST_Difference(geometry geomA, geometry geomB, float8 gridSize = -1);
Returnerar en geometri som representerar den del av geometri A som inte skär geometri B. Detta är ekvivalent med A - ST_Intersection(A,B). Om A är helt innesluten i B returneras en tom atomgeometri av lämplig typ.
![]() | |
Detta är den enda överlagringsfunktionen där inmatningsordningen har betydelse. ST_Difference(A, B) returnerar alltid en del av A. |
If the optional gridSize parameter is given (GEOS-3.9.0 or higher required), all result vertices are guaranteed to fall on a snap-rounded grid of the specified size. Note that operations performed on a grid may contain small artifacts produced during grid alignment, see ST_ReducePrecision.
Utförs av GEOS-modulen
Förbättrad: 3.1.0 accepterar en gridSize-parameter.
Kräver GEOS >= 3.9.0 för att använda parametern gridSize.
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s2.1.1.3
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.20
Denna funktion stöder 3d och kommer inte att tappa z-index. Resultatet beräknas dock endast med hjälp av XY. De resulterande Z-värdena kopieras, medelvärdesbildas eller interpoleras.
Skillnaden mellan 2D-linestrings.
SELECT ST_Difference('LINESTRING(50 100,50 200)'::geometry,
'LINESTRING(50 50,50 150)'::geometry
);LINESTRING(50 150,50 200)
Skillnaden mellan 3D-punkter.
SELECT ST_Difference('MULTIPOINT(-118.58 38.38 5,-118.60 38.329 6,-118.614 38.281 7)' :: geometry,
'POINT(-118.614 38.281 5)' :: geometry
);MULTIPOINT(-118.6 38.329 6,-118.58 38.38 5)
ST_Intersection — Beräknar en geometri som representerar den delade delen av geometrierna A och B.
geometry ST_Intersection( geometry geomA , geometry geomB , float8 gridSize = -1 );
geography ST_Intersection( geography geogA , geography geogB );
Returnerar en geometri som representerar punktuppsättningens skärningspunkt mellan två geometrier. Med andra ord, den del av geometri A och geometri B som delas mellan de två geometrierna.
Om geometrierna inte har några gemensamma punkter (dvs. är disjunkta) returneras en tom atomgeometri av lämplig typ.
If the optional gridSize parameter is given (GEOS-3.9.0 or higher required), all result vertices are guaranteed to fall on a snap-rounded grid of the specified size. Note that operations performed on a grid may contain small artifacts produced during grid alignment, see ST_ReducePrecision.
ST_Intersection i kombination med ST_Intersects är användbart för att klippa geometrier, t.ex. i frågor om bounding box, buffert eller region där du bara behöver den del av en geometri som ligger inom ett land eller en region av intresse.
![]() | |
Spatial predicates such as ST_Intersects and overlay functions such as |
![]() | |
|
![]() | |
Denna funktion kommer att släppa M-koordinatvärdena om de finns. |
![]() | |
If working with 3D geometries, you may want to use SFCGAL based CG_3DIntersection which does a proper 3D intersection for 3D geometries. Although this function works with Z-coordinate, it does an averaging of Z-Coordinate. |
Utförs av GEOS-modulen
Förbättrad: 3.1.0 accepterar en gridSize-parameter
Kräver GEOS >= 3.9.0 för att använda parametern gridSize
Ändrat: 3.0.0 är inte beroende av SFCGAL.
Tillgänglighet: 1.5 stöd för datatypen Geography infördes.
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s2.1.1.3
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.18
Denna funktion stöder 3d och kommer inte att tappa z-index. Resultatet beräknas dock endast med hjälp av XY. De resulterande Z-värdena kopieras, medelvärdesbildas eller interpoleras.
SELECT ST_Intersection('POINT(0 0)'::geometry, 'LINESTRING ( 2 0,0 2 )'::geometry);PUNKT EMPTY
SELECT ST_Intersection('POINT(0 0)'::geometry, 'LINESTRING ( 0 0,0 2 )'::geometry);PUNKT(0 0)
Klipp ut alla linjer (spår) efter land. Här antar vi att landets geom är POLYGON eller MULTIPOLYGON. OBS: vi behåller bara korsningar som resulterar i en LINESTRING eller MULTILINESTRING eftersom vi inte bryr oss om spår som bara delar en punkt. Dumpen behövs för att expandera en geometrisamling till enskilda MULT*-delar. Nedanstående är ganska generisk och kommer att fungera för polys, etc. genom att bara ändra var klausulen.
select clipped.gid, clipped.f_name, clipped_geom
from (
select trails.gid, trails.f_name,
(ST_Dump(ST_Intersection(country.geom, trails.geom))).geom clipped_geom
from country
inner join trails on ST_Intersects(country.geom, trails.geom)
) as clipped
where ST_Dimension(clipped.clipped_geom) = 1;För polys, t.ex. polygonlandmärken, kan du också använda det ibland snabbare hacket att buffring av allt med 0,0 utom en polygon resulterar i en tom geometrisamling. (Så en geometrisamling som innehåller polygoner, linjer och punkter som buffras med 0,0 skulle bara lämna kvar polygonerna och upplösa samlingens skal)
select poly.gid,
ST_Multi(ST_Buffer(ST_Intersection(country.geom, poly.geom),
0.0
)
) clipped_geom
from country
inner join poly on ST_Intersects(country.geom, poly.geom)
where not ST_IsEmpty(ST_Buffer(ST_Intersection(country.geom, poly.geom), 0.0));Note this is not a true 3D intersection. It uses 2.5D geometries (geometries with Z ordinates, but where calculations are performed in 2D). The same input is compared with CG_3DIntersection, which performs a true 3D intersection.
WITH data AS (
SELECT 'LINESTRING Z (2 2 6,1.5 1.5 7,1 1 8,0.5 0.5 8,0 0 10)'::geometry AS input_linestring,
'POLYGON Z ((0 0 8,0 1 8,1 1 8,1 0 8,0 0 8))'::geometry AS input_polygon
)
SELECT input_linestring AS input_linestring,
input_polygon AS input_polygon,
ST_Intersection(input_linestring, input_polygon) AS intersection_2d,
CG_3DIntersection(input_linestring, input_polygon) AS intersection_3d
FROM data;LINESTRING Z (2 2 6,1.5 1.5 7,1 1 8,0.5 0.5 8,0 0 10) | POLYGON Z ((0 0 8,0 1 8,1 1 8,1 0 8,0 0 8)) | LINESTRING Z (1 1 8,0.5 0.5 8,0 0 10) | LINESTRING Z (1 1 8,0.5 0.5 8)
ST_MemUnion — Aggregatfunktion som kombinerar geometrier på ett minneseffektivt men långsammare sätt
geometry ST_MemUnion(geometry set geomfield);
En aggregeringsfunktion som förenar indatageometrierna och sammanfogar dem för att producera en resultatgeometri utan överlappningar. Utdata kan vara en enskild geometri, en MultiGeometry eller en Geometry Collection.
![]() | |
Ger samma resultat som ST_Union, men använder mindre minne och mer processortid. Denna aggregatfunktion fungerar genom att geometrierna sammanfogas stegvis, i motsats till ST_Union-aggregatet som först ackumulerar en matris och sedan sammanfogar innehållet med hjälp av en snabb algoritm. |
Denna funktion stöder 3d och kommer inte att tappa z-index. Resultatet beräknas dock endast med hjälp av XY. De resulterande Z-värdena kopieras, medelvärdesbildas eller interpoleras.
SELECT id,
ST_MemUnion(geom) as singlegeom
FROM sometable f
GROUP BY id;
ST_Node — Noder en samling av linjer.
geometry ST_Node(geometry geom);
Returnerar en (Multi)LineString som representerar den fullständigt nodade versionen av en samling linestrings. Nodningen bevarar alla indatans noder och introducerar minsta möjliga antal nya noder. Det resulterande linjeverket är upplöst (dubbletter av linjer tas bort).
Detta är ett bra sätt att skapa helt kodade linjearbeten som kan användas som underlag för ST_Polygonize.
ST_UnaryUnion kan också användas för att nodera och lösa upp linjeverk. Det finns ett alternativ för att ange en gridSize, vilket kan ge enklare och mer robusta resultat. Se även ST_Union för en aggregerad variant.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Utförs av GEOS-modulen.
Tillgänglighet: 2.0.0
Ändrad: 2.4.0 denna funktion använder GEOSNode internt istället för GEOSUnaryUnion. Detta kan leda till att de resulterande linestrings har en annan ordning och riktning jämfört med PostGIS < 2.4.
Noding a 3D LineString which self-intersects.
SELECT ST_Node('LINESTRINGZ(0 0 0, 10 10 10, 0 10 5, 10 0 3)'::geometry) As output;MULTILINESTRING Z ((0 0 0,5 5 4.5),(5 5 4.5,10 10 10,0 10 5,5 5 4.5),(5 5 4.5,10 0 3))
Kodning av två LineStrings som delar gemensamt linework. Observera att resultatets linjeföring är upplöst.
SELECT ST_Node('MULTILINESTRING ((2 5,2 1,7 1),(6 1,4 1,2 3,2 5))'::geometry) As output;MULTILINESTRING((2 5,2 3),(2 3,2 1,4 1),(4 1,2 3),(4 1,6 1),(6 1,7 1))
ST_Split — Returnerar en samling geometrier som skapats genom att dela en geometri med en annan geometri.
geometry ST_Split(geometry input, geometry blade);
Funktionen stöder delning av en LineString med en (Multi)Point-, (Multi)LineString- eller (Multi)Polygon-gräns, eller en (Multi)Polygon med en LineString. När en (Multi)Polygon används som blad, används dess linjära komponenter (gränsen) för att dela upp indata. Den resulterande geometrin är alltid en samling.
Denna funktion är på sätt och vis motsatsen till ST_Union. Genom att tillämpa ST_Union på den returnerade samlingen bör man teoretiskt sett få fram den ursprungliga geometrin (även om detta kanske inte är exakt fallet på grund av numerisk avrundning).
![]() | |
Om inmatningen och bladet inte korsar varandra på grund av problem med numerisk precision kanske inmatningen inte delas som förväntat. För att undvika denna situation kan det vara nödvändigt att först fästa inmatningen på bladet med hjälp av ST_Snap med en liten tolerans. |
Tillgänglighet: 2.0.0 kräver GEOS
Förbättrad: 2.2.0 stöd för att dela en linje med en multilinje, en multipunkt eller (multi)polygongräns infördes.
Förbättrad: 2.5.0 stöd för att dela en polygon med en multilinje infördes.
Split a circular polygon by a diagonal line.
SELECT
ST_Split(
ST_Buffer('POINT(100 90)'::geometry, 50),
'LINESTRING(10 10,190 190)'::geometry
);GEOMETRYCOLLECTION(POLYGON((150 90,149 80.2,146.2 70.9,141.6 62.2,135.4 54.6,127.8 48.4,119.1 43.8,109.8 41,100 40,90.2 41,80.9 43.8,72.2 48.4,64.6 54.6,60.1 60.1,129.9 129.9,135.4 125.4,141.6 117.8,146.2 109.1,149 99.8,150 90)), POLYGON((60.1 60.1,58.4 62.2,53.8 70.9,51 80.2,50 90,51 99.8,53.8 109.1,58.4 117.8,64.6 125.4,72.2 131.6,80.9 136.2,90.2 139,100 140,109.8 139,119.1 136.2,127.8 131.6,129.9 129.9,60.1 60.1)))
Dela en MultiLineString genom en punkt, där punkten ligger exakt på båda LineStrings element.
SELECT ST_Split('MULTILINESTRING((10 10,190 190),(15 15,30 30,100 90))',
ST_Point(30, 30));GEOMETRYCOLLECTION(
LINESTRING(10 10,30 30),
LINESTRING(30 30,190 190),
LINESTRING(15 15,30 30),
LINESTRING(30 30,100 90)
)Dela en LineString med en punkt, där punkten inte ligger exakt på linjen. Visar hur man använder ST_Snap för att snäppa linjen till punkten så att den kan delas.
WITH data AS (SELECT
'LINESTRING(0 0,100 100)'::geometry AS line,
'POINT(51 50)':: geometry AS point
)
SELECT ST_Split(ST_Snap(line, point, 1), point) AS snapped_split,
ST_Split(line, point) AS not_snapped_not_split
FROM data;-[ RECORD 1 ]--------- snapped_split | GEOMETRYCOLLECTION(LINESTRING(0 0,51 50), LINESTRING(51 50,100 100)) not_snapped_not_split | GEOMETRYCOLLECTION(LINESTRING(0 0,100 100))
ST_Subdivide — Beräknar en rätlinjig subdivision av en geometri.
setof geometry ST_Subdivide(geometry geom, integer max_vertices=256, float8 gridSize = -1);
Returnerar en uppsättning geometrier som är resultatet av att dela in geom i delar med hjälp av rätlinjiga linjer, där varje del inte innehåller mer än max_vertices.
max_vertices måste vara 5 eller mer, eftersom det behövs 5 punkter för att representera en sluten låda.
If the optional gridSize parameter is given (GEOS-3.9.0 or higher required), all result vertices are guaranteed to fall on a snap-rounded grid of the specified size. Note that operations performed on a grid may contain small artifacts produced during grid alignment, see ST_ReducePrecision.
Punkt-i-polygon och andra spatiala operationer är normalt snabbare för indexerade, indelade datamängder. Eftersom avgränsningsboxarna för delarna vanligtvis täcker ett mindre område än den ursprungliga geometrins bbox, ger indexfrågor färre "hit"-fall. "Träff"-fallen går snabbare eftersom de spatiala operationer som utförs av indexets omkontroll bearbetar färre punkter.
![]() | |
When casting a subdivided geometry to geography, the resulting geography may differ from the original. Subdivision adds vertices in planar (geometry) space. If vertices are inserted along the boundary, they will alter the geographical representation, where edges are interpreted as geodesic segments. To minimize distortion, first densify the geography using ST_Segmentize to add geodesic vertices, then cast to geometry before subdivision. |
![]() | |
Detta är en set-returning function (SRF) som returnerar en uppsättning rader som innehåller enskilda geometrivärden. Den kan användas i en SELECT-lista eller en FROM-sats för att producera en resultatuppsättning med en post för varje resultatgeometri. |
Utförs av GEOS-modulen.
Tillgänglighet: 2.2.0
Förbättrad: 2.5.0 återanvänder befintliga punkter vid polygondelning, antalet vertex sänks från 8 till 5.
Förbättrad: 3.1.0 accepterar en gridSize-parameter.
Kräver GEOS >= 3.9.0 för att använda parametern gridSize
Exempel: Dela upp en polygon i delar med högst 10 hörn och tilldela varje del ett unikt id.
SELECT row_number() OVER() As rn,geom As wkt
FROM (SELECT ST_Subdivide('POLYGON((132 10,119 23,85 35,68 29,66 28,49 42,32 56,22 64,32 110,40 119,36 150,
57 158,75 171,92 182,114 184,132 186,146 178,176 184,179 162,184 141,190 122,
190 100,185 79,186 56,186 52,178 34,168 18,147 13,132 10))'::geometry, 10)) AS f(geom);
rn │ wkt ────┼──────────────────────────────────────────────────────────────────────────────────────────────────────────────── 1 │ POLYGON((85 35,68 29,66 28,32 56,22 64,29.82608695652174 100,119 100,119 23,85 35)) 2 │ POLYGON((186 52,178 34,168 18,147 13,132 10,119 23,119 56,186 56,186 52)) 3 │ POLYGON((185 79,186 56,119 56,119 100,190 100,185 79)) 4 │ POLYGON((40 119,36 150,57 158,75 171,92 182,114 184,114 100,29.82608695652174 100,32 110,40 119)) 5 │ POLYGON((132 186,146 178,176 184,179 162,184 141,190 122,190 100,114 100,114 184,132 186))
Example: Densify a long geography line using ST_Segmentize(geography, distance), and use ST_Subdivide to split the resulting line into sublines of 8 vertices. Densification minimizes the impact of changes to the geography representation of a geometry when subdividing.
SELECT ST_Subdivide(ST_Segmentize('LINESTRING(0 0,85 85)'::geography,
1200000)::geometry, 8);LINESTRING(0 0,0.487578359029357 5.57659056746196,0.984542144675897 11.1527721155093,1.50101059639722 16.7281035483571,1.94532113630331 21.25) LINESTRING(1.94532113630331 21.25,2.04869538062779 22.3020741387339,2.64204641967673 27.8740533545155,3.29994062412787 33.443216802941,4.04836719489742 39.0084282520239,4.59890468420694 42.5) LINESTRING(4.59890468420694 42.5,4.92498503922732 44.5680389206321,5.98737409390639 50.1195229244701,7.3290919767674 55.6587646879025,8.79638749938413 60.1969505994924) LINESTRING(8.79638749938413 60.1969505994924,9.11375579533779 61.1785363177625,11.6558166691368 66.6648504160202,15.642041247655 72.0867690601745,22.8716627200212 77.3609628116894,24.6991785131552 77.8939011989848) LINESTRING(24.6991785131552 77.8939011989848,39.4046096622744 82.1822848017636,44.7994523421035 82.5156766227011) LINESTRING(44.7994523421035 82.5156766227011,85 85)
Ett exempel: Dela upp de komplexa geometrierna i en tabell på plats. De ursprungliga geometriposterna tas bort från källtabellen och nya poster för varje underindelad resultatgeometri infogas.
WITH complex_areas_to_subdivide AS (
DELETE from polygons_table
WHERE ST_NPoints(geom)
> 255
RETURNING id, column1, column2, column3, geom
)
INSERT INTO polygons_table (fid, column1, column2, column3, geom)
SELECT fid, column1, column2, column3,
ST_Subdivide(geom, 255) as geom
FROM complex_areas_to_subdivide;
Exempel: Skapa en ny tabell som innehåller indelade geometrier och behåll nyckeln för den ursprungliga geometrin så att den nya tabellen kan kopplas till källtabellen. Eftersom ST_Subdivide är en set-returning (tabell)-funktion som returnerar en uppsättning rader med ett enda värde, producerar denna syntax automatiskt en tabell med en rad för varje resultatdel.
CREATE TABLE subdivided_geoms AS
SELECT pkey, ST_Subdivide(geom) AS geom
FROM original_geoms;
ST_SymDifference — Beräknar en geometri som representerar de delar av geometrierna A och B som inte korsar varandra.
geometry ST_SymDifference(geometry geomA, geometry geomB, float8 gridSize = -1);
Returnerar en geometri som representerar de delar av geonetrierna A och B som inte skär varandra. Detta är likvärdigt med ST_Union(A,B) - ST_Intersection(A,B). Det kallas en symmetrisk differens eftersom ST_SymDifference(A,B) = ST_SymDifference(B,A)..
If the optional gridSize parameter is given (GEOS-3.9.0 or higher required), all result vertices are guaranteed to fall on a snap-rounded grid of the specified size. Note that operations performed on a grid may contain small artifacts produced during grid alignment, see ST_ReducePrecision.
Utförs av GEOS-modulen
Förbättrad: 3.1.0 accepterar en gridSize-parameter.
Kräver GEOS >= 3.9.0 för att använda parametern gridSize
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s2.1.1.3
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.21
Denna funktion stöder 3d och kommer inte att tappa z-index. Resultatet beräknas dock endast med hjälp av XY. De resulterande Z-värdena kopieras, medelvärdesbildas eller interpoleras.
This example shows a 2D-safe symmetric difference of two LineStrings.
SELECT ST_SymDifference('LINESTRING(50 100,50 200)',
'LINESTRING(50 50,50 150)'
);MULTILINESTRING((50 150,50 200),(50 50,50 100))
In 3D, this example does not produce the expected result.
SELECT ST_SymDifference('LINESTRING(1 2 1,1 4 2)',
'LINESTRING(1 1 3,1 3 4)');MULTILINESTRING((1 3 4,1 4 2),(1 1 3,1 2 1))
ST_UnaryUnion — Beräknar sammanslagningen av komponenterna i en enda geometri.
geometry ST_UnaryUnion(geometry geom, float8 gridSize = -1);
En variant av ST_Union med en enda inmatning. Inmatningen kan vara en enskild geometri, en MultiGeometry eller en GeometryCollection. Unionen tillämpas på de enskilda elementen i indata.
Denna funktion kan användas för att fixa MultiPolygoner som är ogiltiga på grund av överlappande komponenter. Alla indatakomponenter måste dock vara giltiga. En ogiltig indatakomponent, t.ex. en polygon med fluga, kan orsaka ett fel. Av denna anledning kan det vara bättre att använda ST_MakeValid.
En annan användning av denna funktion är att nodera och lösa upp en samling linestrings som korsar eller överlappar varandra för att göra dem enkla.(ST_Node gör också detta, men det ger inte gridSize-alternativet.)
Det är möjligt att kombinera ST_UnaryUnion med ST_Collect för att finjustera hur många geometrier som ska förenas samtidigt. Detta möjliggör en avvägning mellan minnesanvändning och beräkningstid, vilket ger en balans mellan ST_Union och ST_MemUnion.
If the optional gridSize parameter is given (GEOS-3.9.0 or higher required), all result vertices are guaranteed to fall on a snap-rounded grid of the specified size. Note that operations performed on a grid may contain small artifacts produced during grid alignment, see ST_ReducePrecision.
Denna funktion stöder 3d och kommer inte att tappa z-index. Resultatet beräknas dock endast med hjälp av XY. De resulterande Z-värdena kopieras, medelvärdesbildas eller interpoleras.
Förbättrad: 3.1.0 accepterar en gridSize-parameter.
Kräver GEOS >= 3.9.0 för att använda parametern gridSize
Tillgänglighet: 2.0.0
ST_Union, ST_MemUnion, ST_MakeValid, ST_Collect, ST_Node, ST_ReducePrecision
ST_Union — Beräknar en geometri som representerar punktuppsättningssammanslagningen av indatageometrierna.
geometry ST_Union(geometry g1, geometry g2);
geometry ST_Union(geometry g1, geometry g2, float8 gridSize);
geometry ST_Union(geometry[] g1_array);
geometry ST_Union(geometry set g1field);
geometry ST_Union(geometry set g1field, float8 gridSize);
Förenar indatageometrierna och sammanfogar geometrierna för att producera en resultatgeometri utan överlappningar. Utdata kan vara en atomär geometri, en MultiGeometry eller en Geometry Collection. Finns i flera varianter:
Variant med två inmatningar: returnerar en geometri som är en förening av två inmatningsgeometrier. Om någon av indata är NULL, returneras NULL.
Array variant: returnerar en geometri som är en sammanslagning av en array av geometrier.
Aggregerad variant: returnerar en geometri som är föreningen av en raduppsättning geometrier. ST_Union () -funktionen är en "aggregerad" funktion i terminologin för PostgreSQL. Det betyder att den fungerar på rader med data, på samma sätt som SUM () och AVG () -funktionerna gör och som de flesta aggregat ignorerar den också NULL-geometrier.
Se ST_UnaryUnion för en variant utan aggregat och med en enda inmatning.
ST_Union-arrayen och set-varianterna använder den snabba Cascaded Union-algoritmen som beskrivs i http://blog.cleverelephant.ca/2009/01/must-faster-unions-in-postgis-14.html
If the optional gridSize parameter is given (GEOS-3.9.0 or higher required), all result vertices are guaranteed to fall on a snap-rounded grid of the specified size. Note that operations performed on a grid may contain small artifacts produced during grid alignment, see ST_ReducePrecision.
![]() | |
ST_Collect kan ibland användas i stället för ST_Union, om resultatet inte behöver vara icke-överlappande. ST_Collect är vanligtvis snabbare än ST_Union eftersom den inte utför någon bearbetning av de insamlade geometrierna. |
Utförs av GEOS-modulen.
ST_Union skapar MultiLineString och syr inte ihop LineStrings till en enda LineString. Använd ST_LineMerge för att sy LineStrings.
OBS: den här funktionen hette tidigare GeomUnion(), som döptes om från "Union" eftersom UNION är ett reserverat SQL-ord.
Förbättrad: 3.1.0 accepterar en gridSize-parameter.
Kräver GEOS >= 3.9.0 för att använda parametern gridSize
Ändrat: 3.0.0 är inte beroende av SFCGAL.
Tillgänglighet: 1.4.0 - ST_Union förbättrades. ST_Union (geomarray) introducerades och även snabbare aggregerad samling i PostgreSQL.
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s2.1.1.3
![]() | |
Aggregerad version definieras inte uttryckligen i OGC SPEC. |
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 5.1.19 z-index (höjd) när polygoner är inblandade.
Denna funktion stöder 3d och kommer inte att tappa z-index. Resultatet beräknas dock endast med hjälp av XY. De resulterande Z-värdena kopieras, medelvärdesbildas eller interpoleras.
Aggregerat exempel
SELECT id,
ST_Union(geom) as singlegeom
FROM sometable f
GROUP BY id;
Icke-aggregerat exempel
SELECT ST_Union('POINT(1 2)'::geometry, 'POINT(-2 3)'::geometry);MULTIPOINT((1 2),(-2 3))
SELECT ST_Union('POINT(1 2)'::geometry, 'POINT(1 2)'::geometry);POINT(1 2)
3D example - sort of supports 3D (and with mixed geometry types!)
SELECT ST_Union(geom)
FROM (
SELECT 'POLYGON Z((-7 4.2 5,-7.1 4.2 5,-7.1 4.3 5,-7 4.2 5))'::geometry geom
UNION ALL
SELECT 'POINT Z(5 5 5)'::geometry geom
UNION ALL
SELECT 'POINT Z(-2 3 1)'::geometry geom
UNION ALL
SELECT 'LINESTRING Z(5 5 5,10 10 10)'::geometry geom
) AS foo;GEOMETRYCOLLECTION(POINT(-2 3 1), LINESTRING(5 5 5,10 10 10), POLYGON((-7 4.2 5,-7.1 4.2 5,-7.1 4.3 5,-7 4.2 5)))
This 3D example does not mix dimensions.
SELECT ST_Union(geom)
FROM (
SELECT 'POLYGON((-7 4.2 2,-7.1 4.2 3,-7.1 4.3 2,-7 4.2 2))'::geometry geom
UNION ALL
SELECT 'POINT(5 5 5)'::geometry geom
UNION ALL
SELECT 'POINT(-2 3 1)'::geometry geom
UNION ALL
SELECT 'LINESTRING(5 5 5,10 10 10)'::geometry geom
) AS foo;GEOMETRYCOLLECTION(POINT(-2 3 1), LINESTRING(5 5 5,10 10 10), POLYGON((-7 4.2 2,-7.1 4.2 3,-7.1 4.3 2,-7 4.2 2)))
This example unions an array built from a query.
SELECT ST_Union(ARRAY(SELECT geom FROM sometable));
This example unions an array of linestrings.
SELECT ST_Union(ARRAY[
'LINESTRING(1 2,3 4)'::geometry,
'LINESTRING(4 5,5 6)'::geometry
]) As wktunion;MULTILINESTRING((1 2,3 4),(4 5,5 6))
Dessa funktioner beräknar geometriska constructions eller ändrar geometrins storlek eller form.
ST_Buffer — Beräknar en geometri som täcker alla punkter inom ett givet avstånd från en geometri.
geometry ST_Buffer(geometry g1, float radius_of_buffer, text buffer_style_parameters = '');
geometry ST_Buffer(geometry g1, float radius_of_buffer, integer num_seg_quarter_circle);
geography ST_Buffer(geography g1, float radius_of_buffer, text buffer_style_parameters);
geography ST_Buffer(geography g1, float radius_of_buffer, integer num_seg_quarter_circle);
Beräknar en POLYGON eller MULTIPOLYGON som representerar alla punkter vars avstånd från en geometri/geografi är mindre än eller lika med ett givet avstånd. Ett negativt avstånd krymper geometrin i stället för att expandera den. Ett negativt avstånd kan krympa en polygon helt och hållet, i vilket fall POLYGON EMPTY returneras. För punkter och linjer returnerar negativa avstånd alltid tomma resultat.
För geometri anges avståndet i enheterna för geometrins spatiala referenssystem. För geografi anges avståndet i meter.
Den valfria tredje parametern styr buffertens noggrannhet och stil. Noggrannheten för cirkelbågar i bufferten anges som antalet linjesegment som används för att approximera en kvartscirkel (standard är 8). Buffertstilen kan specificeras genom att tillhandahålla en lista med blankseparerade nyckel=värde-par enligt följande:
'quad_segs=#' : antal linjesegment som används för att approximera en kvartscirkel (standard är 8).
'endcap=round|flat|square' : endcap-stil (standard är "round"). "butt" accepteras som synonym för "flat".
'join=round|mitre|bevel' : fogningsstil (standard är "round"). "Miter" accepteras som synonym till "mitre".
'mitre_limit=#.#' : gräns för mitraförhållande (påverkar endast miterad fogning). 'miter_limit' accepteras som en synonym till 'mitre_limit'.
'side=both|left|right' : defaults to 'both'. 'left' or 'right' performs a single-sided buffer on the geometry, with the buffered side relative to the direction of the line. This is only applicable to LINESTRING geometry and does not affect POINT or POLYGON geometries. By default end caps are square when 'left' or 'right' are specified.
![]() | |
|
![]() | |
Buffer kan hantera ogiltiga indata och utdata är alltid en giltig polygonal geometri. Buffring med avstånd 0 används ibland som ett sätt att reparera ogiltiga polygoner. ST_MakeValid är mer lämplig för denna process eftersom den kan hantera multipolygoner. |
![]() | |
Buffring används ibland för att utföra en sökning inom avstånd. För detta användningsfall är det mer effektivt att använda ST_DWithin. |
![]() | |
Denna funktion ignorerar Z-dimensionen. Den ger alltid ett 2D-resultat även när den används på en 3D-geometri. |
Förbättrad: 2.5.0 - ST_Buffer geometri stöd förbättrades för att möjliggöra sidobuffring specifikation side=both|left|right.
Tillgänglighet: 1.5 - ST_Buffer har förbättrats för att stödja olika ändkapslar och join-typer. Dessa är användbara för att t.ex. konvertera väglinjer till polygonvägar med platta eller fyrkantiga kanter istället för rundade kanter. Tunt omslag för geografi har lagts till.
Utförs av GEOS-modulen.
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s2.1.1.3
Denna metod implementerar SQL/MM-specifikationen. SQL-MM IEC 13249-3: 5.1.30
The textual results are rounded to whole coordinate units for readability. Each result remains available as text, while the manual initially favors the shared input/output figure.
|
quad_segs=8 (standard) Code SELECT ST_Buffer(
ST_GeomFromText('POINT(100 90)'),
50, 'quad_segs=8');Rasterutdata POLYGON((150 90,149 80,146 71,142 62,135 55,128 48,119 44,110 41,100 40,90 41,81 44,72 48,65 55,58 62,54 71,51 80,50 90,51 100,54 109,58 118,65 125,72 132,81 136,90 139,100 140,110 139,119 136,128 132,135 125,142 118,146 109,149 100,150 90)) Figure |
quad_segs=2 Code SELECT ST_Buffer(
ST_GeomFromText('POINT(100 90)'),
50, 'quad_segs=2');Rasterutdata POLYGON((150 90,135 55,100 40,65 55,50 90,65 125,100 140,135 125,150 90)) Figure |
|
endcap=rund join=rund (standard) Code SELECT ST_Buffer(
ST_GeomFromText('LINESTRING(50 50,150 150,150 50)'),
10, 'endcap=round join=round');Rasterutdata POLYGON((143 157,144 158,146 159,148 160,150 160,152 160,154 159,156 158,157 157,158 156,159 154,160 152,160 150,160 50,160 48,159 46,158 44,157 43,156 42,154 41,152 40,150 40,148 40,146 41,144 42,143 43,142 44,141 46,140 48,140 50,140 126,57 43,56 42,54 41,52 40,50 40,48 40,46 41,44 42,43 43,42 44,41 46,40 48,40 50,40 52,41 54,42 56,43 57,143 157)) Figure |
ändkapsel=fyrkantsformad Code SELECT ST_Buffer(
ST_GeomFromText('LINESTRING(50 50,150 150,150 50)'),
10, 'endcap=square join=round');Rasterutdata POLYGON((143 157,144 158,146 159,148 160,150 160,152 160,154 159,156 158,157 157,158 156,159 154,160 152,160 150,160 50,160 40,140 40,140 126,57 43,50 36,36 50,143 157)) Figure |
|
ändkapsel=platt Code SELECT ST_Buffer(
ST_GeomFromText('LINESTRING(50 50,150 150,150 50)'),
10, 'endcap=flat join=round');Rasterutdata POLYGON((143 157,144 158,146 159,148 160,150 160,152 160,154 159,156 158,157 157,158 156,159 154,160 152,160 150,160 50,140 50,140 126,57 43,43 57,143 157)) Figure |
skarv=fasad Code SELECT ST_Buffer(
ST_GeomFromText('LINESTRING(50 50,150 150,150 50)'),
10, 'join=bevel');Rasterutdata POLYGON((143 157,160 150,160 50,160 48,159 46,158 44,157 43,156 42,154 41,152 40,150 40,148 40,146 41,144 42,143 43,142 44,141 46,140 48,140 50,140 126,57 43,56 42,54 41,52 40,50 40,48 40,46 41,44 42,43 43,42 44,41 46,40 48,40 50,40 52,41 54,42 56,43 57,143 157)) Figure |
|
join=mitre mitre_limit=5.0 (standard mitre-gräns) Code SELECT ST_Buffer(
ST_GeomFromText('LINESTRING(50 50,150 150,150 50)'),
10, 'join=mitre mitre_limit=5.0');Rasterutdata POLYGON((160 174,160 50,160 48,159 46,158 44,157 43,156 42,154 41,152 40,150 40,148 40,146 41,144 42,143 43,142 44,141 46,140 48,140 50,140 126,57 43,56 42,54 41,52 40,50 40,48 40,46 41,44 42,43 43,42 44,41 46,40 48,40 50,40 52,41 54,42 56,43 57,160 174)) Figure |
skarv=mitra mitre_limit=1 Code SELECT ST_Buffer(
ST_GeomFromText('LINESTRING(50 50,150 150,150 50)'),
10, 'join=mitre mitre_limit=1.0');Rasterutdata POLYGON((148 162,160 157,160 50,160 48,159 46,158 44,157 43,156 42,154 41,152 40,150 40,148 40,146 41,144 42,143 43,142 44,141 46,140 48,140 50,140 126,57 43,56 42,54 41,52 40,50 40,48 40,46 41,44 42,43 43,42 44,41 46,40 48,40 50,40 52,41 54,42 56,43 57,148 162)) Figure |
|
sida=vänster Code SELECT ST_Buffer(
ST_GeomFromText('LINESTRING(50 50,150 150,150 50)'),
10, 'side=left');Rasterutdata POLYGON((150 50,150 150,50 50,43 57,143 157,144 158,146 159,148 160,150 160,152 160,154 159,156 158,157 157,158 156,159 154,160 152,160 150,160 50,150 50)) Figure |
sida=höger Code SELECT ST_Buffer(
ST_GeomFromText('LINESTRING(50 50,150 150,150 50)'),
10, 'side=right');Rasterutdata POLYGON((50 50,150 150,150 50,140 50,140 126,57 43,50 50)) Figure |
|
sida=vänster led=mitre Code SELECT ST_Buffer(
ST_GeomFromText('LINESTRING(50 50,150 150,150 50)'),
10, 'side=left join=mitre');Rasterutdata POLYGON((150 50,150 150,50 50,43 57,160 174,160 50,150 50)) Figure |
right-hand winding, polygon boundary side=left Code SELECT ST_Buffer(
ST_ForceRHR(ST_Boundary(ST_GeomFromText(
'POLYGON ((50 50,50 150,150 150,150 50,50 50))'))),
20, 'side=left');Rasterutdata POLYGON((50 50,50 150,150 150,150 50,50 50)) Figure |
|
right-hand winding, polygon boundary side=right Code SELECT ST_Buffer(
ST_ForceRHR(ST_Boundary(ST_GeomFromText(
'POLYGON ((50 50,50 150,150 150,150 50,50 50))'))),
20, 'side=right');Rasterutdata POLYGON((50 50,50 70,50 150,150 150,150 50,70 50,50 50),(70 70,130 70,130 130,70 130,70 70)) Figure |
A buffered point approximates a circle. A buffered point forcing approximation of (see diagram) 2 points per quarter circle is poly with 8 sides (see diagram)
SELECT ST_NPoints(ST_Buffer('POINT(100 90)'::geometry, 50)) As promisingcircle_pcount,
ST_NPoints(ST_Buffer('POINT(100 90)'::geometry, 50, 2)) As lamecircle_pcount;
promisingcircle_pcount | lamecircle_pcount
------------------------+-------------------
33 | 9
A lighter, less smooth circle using only 2 points per quarter circle is an octagon.
The following example creates a 100 meter octagon in NAD83 longitude/latitude by transforming to the Massachusetts state plane meter projection and then buffering. The figure shows the input and output in separate panels because the coordinates are in different SRIDs.
WITH input AS (
SELECT ST_SetSRID(ST_Point(-71.063526, 42.35785), 4269) AS point_4269
), projected AS (
SELECT point_4269,
ST_Transform(point_4269, 26986) AS point_26986
FROM input
)
SELECT point_4269 AS input_point_4269,
ST_Buffer(point_26986, 100, 2) AS octagon_26986
FROM projected;SRID=4269;POINT(-71.063526 42.35785) | SRID=26986;POLYGON((236057.5905746494 900908.7599186979,236028.30125276805 900838.0492405792,235957.5905746494 900808.7599186979,235886.87989653074 900838.0492405792,235857.5905746494 900908.7599186979,235886.87989653074 900979.4705968165,235957.5905746494 901008.7599186979,236028.30125276805 900979.4705968165,236057.5905746494 900908.7599186979))
Buffering a polygon by a positive distance and then by the same negative distance is a morphological closing operation. It can be useful for smoothing noisy boundaries, such as simplifying a coastline by removing narrow inlets and bays. The result intentionally changes the shape and area of the input, and the distance must be chosen in the units of the input SRS. For data in a geographic SRS, transform to a projected SRS suited to the operation first; for cartographic visualization in Web Mercator, using that display SRS can be appropriate.
Smooth a coastline using a 1 km closing operation, then simplify the result. The example uses Massachusetts State Plane meter units for the operation.
WITH projected AS ( SELECT id, ST_Transform(geom, 26986) AS geom FROM coast ), closed AS ( SELECT id, ST_Buffer(ST_Buffer(geom, 1000), -1000) AS geom FROM projected ) SELECT id, ST_Transform(ST_SimplifyPreserveTopology(geom, 50), 4326) AS geom FROM closed;
The same technique is described in Paul Ramsey's Removing Complexities. The final simplification step is optional; use ST_SimplifyPreserveTopology when polygonal validity matters, and check the result against the cartographic or analytical tolerance required by the application.
A small negative buffer can also be used as a heuristic to find narrow polygon spikes. The query below compares how much area and perimeter remain after erosion. A large erosion_index indicates that the perimeter dropped proportionally more than the area. This is only a preselection aid; the threshold and buffer distance must be chosen for the data units and the kind of spike being checked.
WITH sample(id, geom) AS (
VALUES
('plain', 'POLYGON((0 0,10 0,10 10,0 10,0 0))'::geometry),
('spike', 'POLYGON((0 0,10 0,10 10,5.2 10,5 16,4.8 10,0 10,0 0))'::geometry)
),
eroded AS (
SELECT id, geom, ST_Buffer(geom, -0.5) AS eroded_geom
FROM sample
),
scored AS (
SELECT id,
round((
ST_Area(eroded_geom) / ST_Area(geom) /
NULLIF(ST_Perimeter(eroded_geom) / ST_Perimeter(geom), 0)
)::numeric, 3) AS erosion_index
FROM eroded
WHERE NOT ST_IsEmpty(eroded_geom)
)
SELECT id, erosion_index, erosion_index > 1.1 AS possible_spike
FROM scored
ORDER BY id;id | erosion_index | possible_spike -------+---------------+---------------- plain | 0.900 | f spike | 1.147 | t
A variable-distance buffer can be approximated by buffering each vertex of a line by a distance interpolated along the line, building the convex hull for each consecutive pair of vertex buffers, and unioning the segment hulls. As with any geometry buffer, distances are in the units of the input SRS.
Taper a line buffer from 5 to 25 units along the line.
WITH line AS (
SELECT 'LINESTRING(0 0, 100 0, 160 40)'::geometry AS geom
),
vertices AS (
SELECT (dump).path[1] AS n,
(dump).geom AS geom,
line.geom AS line_geom
FROM line
CROSS JOIN LATERAL ST_DumpPoints(line.geom) AS dump
),
radii AS (
SELECT n,
geom,
5 + (25 - 5) * ST_LineLocatePoint(line_geom, geom) AS radius
FROM vertices
),
segments AS (
SELECT n,
geom,
radius,
lead(geom) OVER (ORDER BY n) AS next_geom,
lead(radius) OVER (ORDER BY n) AS next_radius
FROM radii
)
SELECT ST_Union(
ST_ConvexHull(
ST_Collect(
ST_Buffer(geom, radius),
ST_Buffer(next_geom, next_radius)
)
)
) AS tapered_buffer
FROM segments
WHERE next_geom IS NOT NULL;POLYGON((96.758 -16.301,-0.975 -4.904,-1.913 -4.619,-2.778 -4.157,-3.536 -3.536,-4.157 -2.778,-4.619 -1.913,-4.904 -0.975,-5 0,-4.904 0.975,-4.619 1.913,-4.157 2.778,-3.536 3.536,-2.778 4.157,-1.913 4.619,-0.975 4.904,93.101 15.875,142.322 57.678,146.111 60.787,150.433 63.097,155.123 64.52,160 65,164.877 64.52,169.567 63.097,173.889 60.787,177.678 57.678,180.787 53.889,183.097 49.567,184.52 44.877,185 40,184.52 35.123,183.097 30.433,180.787 26.111,177.678 22.322,173.889 19.213,169.567 16.903,106.36 -15.355,103.242 -16.301,100 -16.62,96.758 -16.301))
ST_BuildArea — Skapar en polygonal geometri som bildas av linjerna i en geometri.
geometry ST_BuildArea(geometry geom);
Skapar en ytgeometri som består av de ingående linjerna i indatageometrin. Indata kan vara en LineString, MultiLineString, Polygon, MultiPolygon eller en GeometryCollection. Resultatet är en polygon eller multipolygon, beroende på indata. Om indatalinjerna inte bildar polygoner returneras NULL.
Till skillnad från ST_MakePolygon accepterar denna funktion ringar som bildas av flera linjer och kan bilda valfritt antal polygoner.
Denna funktion omvandlar inre ringar till hål. Om du även vill omvandla inre ringar till polygoner använder du ST_Polygonize.
![]() | |
Ingångslinjen måste vara korrekt nodad för att denna funktion ska fungera korrekt. ST_Node kan användas för att noda linjer. Om inmatningslinjerna korsar varandra kommer denna funktion att producera ogiltiga polygoner. ST_MakeValid kan användas för att säkerställa att utdata är giltiga. |
Tillgänglighet: 1.1.0
Building an area from five input lines.
WITH data(geom) AS (VALUES
('LINESTRING (180 40,30 20,20 90)'::geometry),
('LINESTRING (180 40,160 160)'::geometry),
('LINESTRING (160 160,80 190,80 120,20 90)'::geometry),
('LINESTRING (80 60,120 130,150 80)'::geometry),
('LINESTRING (80 60,150 80)'::geometry)
)
SELECT ST_BuildArea(ST_Collect(geom )) AS wkt
FROM data;POLYGON((180 40,30 20,20 90,80 120,80 190,160 160,180 40),(150 80,120 130,80 60,150 80))
Create a donut from two circular polygons.
WITH input AS (
SELECT 'POINT(100 90)'::geometry AS geom
),
rings AS (
SELECT ST_Buffer(geom, 25, 'quad_segs=1') AS inring,
ST_Buffer(geom, 50, 'quad_segs=1') AS outring
FROM input
)
SELECT inring AS inner_ring,
outring AS outer_ring,
ST_BuildArea(ST_Collect(inring, outring)) AS area
FROM rings;-[ RECORD 1 ]----- inner_ring | POLYGON((125 90,100 65,75 90,100 115,125 90)) outer_ring | POLYGON((150 90,100 40,50 90,100 140,150 90)) area | POLYGON((150 90,100 40,50 90,100 140,150 90),(125 90,100 115,75 90,100 65,125 90))
Input linework that crosses at non-endpoint intersections must be noded before building areas:
WITH lines(geom) AS (VALUES
('LINESTRING(36 35,45 307)'::geometry),
('LINESTRING(30 290,390 280)'::geometry),
('LINESTRING(320 60,300 310)'::geometry),
('LINESTRING(20 60,320 60)'::geometry),
('LINESTRING(120 140,168 225)'::geometry),
('LINESTRING(140 220,220 150,120 170)'::geometry)
),
noded AS (
SELECT ST_Node(ST_UnaryUnion(ST_Collect(geom))) AS geom FROM lines
)
SELECT ST_BuildArea(geom) AS area
FROM noded;
POLYGON((320 60,36.8 60,44.4 289.6,302.2 282.4,320 60),(156.9 205.3,135.2 167,220 150,156.9 205.3))
ST_Collect, ST_MakePolygon, ST_MakeValid, ST_Node, ST_Polygonize, ST_BdPolyFromText, ST_BdMPolyFromText (wrappers till denna funktion med standard OGC-gränssnitt)
ST_Centroid — Returnerar den geometriska mittpunkten för en geometri.
geometry ST_Centroid(geometry g1);
geography ST_Centroid(geography g1, boolean use_spheroid = true);
Beräknar en punkt som är den geometriska tyngdpunkten för en geometri. För[MULTI]POINTsär centroiden det aritmetiska medelvärdet av de inmatade koordinaterna. För [MULTI]LINESTRINGsberäknas centroiden med hjälp av den viktade längden för varje linjesegment. För [MULTI]POLYGONERberäknas centroiden i termer av area. Om en tom geometri anges, returneras en tom GEOMETRYCOLLECTION. Om NULL anges, returneras NULL. Om CIRCULARSTRING eller COMPOUNDCURVE anges konverteras de till linestring med CurveToLine först, sedan på samma sätt som för LINESTRING
För indata med blandade dimensioner är resultatet lika med centroiden för komponentgeometrierna med den högsta dimensionen (eftersom geometrierna med lägre dimension bidrar med noll "vikt" till centroiden).
Observera att för polygonala geometrier behöver centroiden inte nödvändigtvis ligga i polygonens inre. Se t.ex. diagrammet nedan över centroiden i en C-formad polygon. För att konstruera en punkt som garanterat ligger i det inre av en polygon används ST_PointOnSurface.
Nytt i 2.3.0 : stödjer CIRCULARSTRING och COMPOUNDCURVE (med CurveToLine)
Tillgänglighet: 2.4.0 stöd för geografi infördes.
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 8.1.4, 9.5.5
Centroid of a MultiPoint.
SELECT ST_Centroid( 'MULTIPOINT (8 24,10 92,12 154,17 68,28 10,29 52,29 84,55 50,56 24,131 14,160 180,189 180)');
POINT(60.333 77.667)
Centroid of a LineString.
SELECT ST_Centroid( 'LINESTRING (190 160,10 190,40 90,20 70,10 10,30 40,30 10,110 40,70 10,110 10,140 40,140 10,160 30,180 10)');
POINT(76.191 79.876)
Centroid of a Polygon.
SELECT ST_Centroid( 'POLYGON ((190 190,10 190,10 10,190 10,190 20,160 30,60 30,60 130,190 140,190 190))');
POINT(80.251 113.405)
Centroid of the highest-dimension components of a GeometryCollection.
SELECT ST_Centroid(
'GEOMETRYCOLLECTION (POLYGON ((190 170,180 100,80 140,80 160,130 160,110 180,110 190,180 180,190 170)),
LINESTRING (80 120,120 20,140 70,150 30,180 50,190 10),
MULTIPOINT (19 150,22 49,30 13,32 101,45 35,67 88,75 16))');POINT(143.361 148.263)
SELECT ST_Centroid(g)
FROM ST_GeomFromText('CIRCULARSTRING(0 2,-1 1,0 0,0.5 0,1 0,2 1,1 2,0.5 2,0 2)') AS g ;st_astext ------------- POINT(0.5 1) (1 row)
SELECT ST_Centroid(g)
FROM ST_GeomFromText('COMPOUNDCURVE(CIRCULARSTRING(0 2,-1 1,0 0),(0 0,0.5 0,1 0), CIRCULARSTRING( 1 0,2 1,1 2),(1 2,0.5 2,0 2))' ) AS g;st_astext ------------- POINT(0.5 1) (1 row)
Centroids of the parts of a MultiPolygon.
SELECT ST_Collect(ST_Centroid(geom) ORDER BY path)
FROM ST_Dump('MULTIPOLYGON (
((0 0,0 1,1 1,1 0,0 0)),
((2 2,2 3,3 3,3 2,2 2))
)'::geometry);
MULTIPOINT((0.5 0.5),(2.5 2.5))
ST_ChaikinSmoothing — Returnerar en utjämnad version av en geometri med hjälp av Chaikin-algoritmen
geometry ST_ChaikinSmoothing(geometry geom, integer nIterations = 1, boolean preserveEndPoints = false);
Utjämnar en linjär eller polygonal geometri med hjälp av Chaikins algoritm. Graden av utjämning styrs av parametern nIterations. Vid varje iteration ersätts varje inre toppunkt med två toppunkter som ligger på 1/4 av längden på linjesegmenten före och efter toppunkten. En rimlig grad av utjämning uppnås med 3 iterationer; den maximala graden är begränsad till 5.
Om preserveEndPoints är true utjämnas inte ändpunkterna för Polygon-ringar. Slutpunkterna för LineStrings bevaras alltid.
![]() | |
Antalet toppar fördubblas för varje iteration, så resultatgeometrin kan ha många fler punkter än indata. För att minska antalet punkter kan du använda en förenklingsfunktion på resultatet (se ST_Simplify, ST_SimplifyPreserveTopology och ST_SimplifyVW). |
Resultatet har interpolerade värden för Z- och M-dimensionerna när sådana finns.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Tillgänglighet: 2.5.0
Smoothing a Polygon using 1, 2 and 3 iterations.
SELECT n AS iterations, ST_ChaikinSmoothing(
'POLYGON ((20 20,60 90,10 150,100 190,190 160,130 120,190 50,140 70,120 10,90 60,20 20))', n
) AS smoothed
FROM generate_series(1, 3) AS n;1 | POLYGON((30 37.5,50 72.5,47.5 105,22.5 135,32.5 160,77.5 180,122.5 182.5,167.5 167.5,175 150,145 130,145 102.5,175 67.5,177.5 55,152.5 65,135 55,125 25,112.5 22.5,97.5 47.5,72.5 50,37.5 30,30 37.5)) 2 | POLYGON((35 46.25,45 63.75,49.375 80.625,48.125 96.875,41.25 112.5,28.75 127.5,25 141.25,30 153.75,43.75 165,66.25 175,88.75 180.625,111.25 181.875,133.75 178.75,156.25 171.25,169.375 163.125,173.125 154.375,167.5 145,152.5 135,145 123.125,145 109.375,152.5 93.75,167.5 76.25,175.625 64.375,176.875 58.125,171.25 57.5,158.75 62.5,148.125 62.5,139.375 57.5,132.5 47.5,127.5 32.5,121.875 24.375,115.625 23.125,108.75 28.75,101.25 41.25,91.25 48.125,78.75 49.375,63.75 45,46.25 35,35.625 31.875,31.875 35.625,35 46.25)) 3 | POLYGON((37.5 50.625,42.5 59.375,46.09375 67.96875,48.28125 76.40625,49.0625 84.6875,48.4375 92.8125,46.40625 100.78125,42.96875 108.59375,38.125 116.25,31.875 123.75,27.8125 130.9375,25.9375 137.8125,26.25 144.375,28.75 150.625,33.4375 156.5625,40.3125 162.1875,49.375 167.5,60.625 172.5,71.875 176.40625,83.125 179.21875,94.375 180.9375,105.625 181.5625,116.875 181.09375,128.125 179.53125,139.375 176.875,150.625 173.125,159.53125 169.21875,166.09375 165.15625,170.3125 160.9375,172.1875 156.5625,171.71875 152.03125,168.90625 147.34375,163.75 142.5,156.25 137.5,150.625 132.03125,146.875 126.09375,145 119.6875,145 112.8125,146.875 105.46875,150.625 97.65625,156.25 89.375,163.75 80.625,169.53125 73.28125,173.59375 67.34375,175.9375 62.8125,176.5625 59.6875,175.46875 57.96875,172.65625 57.65625,168.125 58.75,161.875 61.25,156.09375 62.5,150.78125 62.5,145.9375 61.25,141.5625 58.75,137.65625 55,134.21875 50,131.25 43.75,128.75 36.25,126.09375 30.46875,123.28125 26.40625,120.3125 24.0625,117.1875 23.4375,113.90625 24.53125,110.46875 27.34375,106.875 31.875,103.125 38.125,98.75 42.96875,93.75 46.40625,88.125 48.4375,81.875 49.0625,75 48.28125,67.5 46.09375,59.375 42.5,50.625 37.5,43.59375 34.21875,38.28125 32.65625,34.6875 32.8125,32.8125 34.6875,32.65625 38.28125,34.21875 43.59375,37.5 50.625))
Smoothing a LineString using 1, 2 and 3 iterations.
SELECT n AS iterations, ST_ChaikinSmoothing(
'LINESTRING (10 140,80 130,100 190,190 150,140 20,120 120,50 30,30 100)', n
) AS smoothed
FROM generate_series(1, 3) AS n;1 | LINESTRING(10 140,62.5 132.5,85 145,95 175,122.5 180,167.5 160,177.5 117.5,152.5 52.5,135 45,125 95,102.5 97.5,67.5 52.5,45 47.5,30 100) 2 | LINESTRING(10 140,49.375 134.375,68.125 135.625,79.375 141.875,87.5 152.5,92.5 167.5,101.875 176.25,115.625 178.75,133.75 175,156.25 165,170 149.375,175 128.125,171.25 101.25,158.75 68.75,148.125 50.625,139.375 46.875,132.5 57.5,127.5 82.5,119.375 95.625,108.125 96.875,93.75 86.25,76.25 63.75,61.875 51.25,50.625 48.75,41.25 60.625,30 100) 3 | LINESTRING(10 140,39.53125 135.78125,54.0625 134.6875,63.4375 135.3125,70.9375 137.1875,76.5625 140.3125,81.40625 144.53125,85.46875 149.84375,88.75 156.25,91.25 163.75,94.84375 169.6875,99.53125 174.0625,105.3125 176.875,112.1875 178.125,120.15625 177.8125,129.21875 175.9375,139.375 172.5,150.625 167.5,159.6875 161.09375,166.5625 153.28125,171.25 144.0625,173.75 133.4375,174.0625 121.40625,172.1875 107.96875,168.125 93.125,161.875 76.875,156.09375 64.21875,150.78125 55.15625,145.9375 49.6875,141.5625 47.8125,137.65625 49.53125,134.21875 54.84375,131.25 63.75,128.75 76.25,125.46875 85.78125,121.40625 92.34375,116.5625 95.9375,110.9375 96.5625,104.53125 94.21875,97.34375 88.90625,89.375 80.625,80.625 69.375,72.65625 60.625,65.46875 54.375,59.0625 50.625,53.4375 49.375,48.28125 51.71875,43.59375 57.65625,38.4375 70.46875,30 100)
Smoothing a triangle shows the weakest visual change, so it is kept last.
SELECT ST_ChaikinSmoothing(geom) smoothed FROM (SELECT 'POLYGON((0 0,8 8,0 16,0 0))'::geometry geom) AS foo;
POLYGON((2 2,6 6,6 10,2 14,0 12,0 4,2 2))
ST_CatmullRomSmoothing — Returns a smoothed version of a geometry, using the Catmull-Rom spline algorithm
geometry ST_CatmullRomSmoothing(geometry geom, integer nSegments = 5);
Smoothes a linear or polygonal geometry using the Catmull-Rom spline algorithm. Unlike ST_ChaikinSmoothing, this is an interpolating spline: the output curve passes through every original vertex. Between each pair of consecutive original vertices, nSegments - 1 new intermediate points are inserted.
The nSegments parameter controls the density of the output. With nSegments = 5 (the default), each original span is divided into 5 sub-segments (inserting 4 new points per span). The minimum value is 2.
At least 4 input vertices are required to apply smoothing; geometries with fewer vertices are returned unchanged. Points and multipoints are always returned unchanged.
![]() | |
The output vertex count grows as |
Resultatet har interpolerade värden för Z- och M-dimensionerna när sådana finns.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Tillgänglighet: 3.6.0
Smoothing a LineString using nSegments = 5 and 10.
WITH input(geom) AS (VALUES
('LINESTRING (10 140,80 130,100 190,190 150,140 20,120 120,50 30,30 100)'::geometry)
)
SELECT ST_CatmullRomSmoothing(geom, 5) AS segments_5,
ST_CatmullRomSmoothing(geom, 10) AS segments_10
FROM input;LINESTRING(10 140,24.8 136.88,40.4 132.64,55.6 128.96,69.2 127.52,80 130,86.08 139.12,88.24 153.76,89.36 169.84,92.32 183.28,100 190,115.76 189.84,137.68 185.52,160.72 177.28,179.84 165.36,190 150,188.48 126.08,178.64 93.44,164.56 59.76,150.32 32.72,140 20,134.88 28.32,132.24 52.56,130.16 82.64,126.72 108.48,120 120,108.4 111.6,93.2 90,76.8 63.6,61.6 40.8,50 30,42.8 33.76,38.4 46.48,35.6 64.32,33.2 83.44,30 100) | LINESTRING(10 140,17.225 138.685,24.8 136.88,32.575 134.795,40.4 132.64,48.125 130.625,55.6 128.96,62.675 127.855,69.2 127.52,75.025 128.165,80 130,83.71 133.615,86.08 139.12,87.47 146.005,88.24 153.76,88.75 161.875,89.36 169.84,90.43 177.145,92.32 183.28,95.39 187.735,100 190,106.795 190.455,115.76 189.84,126.265 188.185,137.68 185.52,149.375 181.875,160.72 177.28,171.085 171.765,179.84 165.36,186.355 158.095,190 150,190.535 139.61,188.48 126.08,184.345 110.37,178.64 93.44,171.875 76.25,164.56 59.76,157.205 44.93,150.32 32.72,144.415 24.09,140 20,137.01 21.54,134.88 28.32,133.37 39.08,132.24 52.56,131.25 67.5,130.16 82.64,128.73 96.72,126.72 108.48,123.89 116.66,120 120,114.8 117.975,108.4 111.6,101.1 101.925,93.2 90,85 76.875,76.8 63.6,68.9 51.225,61.6 40.8,55.2 33.375,50 30,45.975 30.52,42.8 33.76,40.325 39.24,38.4 46.48,36.875 55,35.6 64.32,34.425 73.96,33.2 83.44,31.775 92.28,30 100)
Smoothing a 4-point collinear line with default nSegments=5 shows the minimal change case.
SELECT ST_CatmullRomSmoothing('LINESTRING(0 0,5 0,10 0,15 0)');LINESTRING(0 0,1 0,2 0,3 0,4 0,5 0,6 0,7 0,8 0,9 0,10 0,11 0,12 0,13 0,14 0,15 0)
Smoothing a Polygon using nSegments = 5 and 10. This larger example is kept last.
WITH input(geom) AS (VALUES
('POLYGON ((20 20,60 90,10 150,100 190,190 160,130 120,190 50,140 70,120 10,90 60,20 20))'::geometry)
)
SELECT ST_CatmullRomSmoothing(geom, 5) AS segments_5,
ST_CatmullRomSmoothing(geom, 10) AS segments_10
FROM input;POLYGON((20 20,22.4 27.12,32.4 40.56,45.2 57.44,56 74.88,60 90,53.52 102.96,39.76 115.68,24.24 127.92,12.48 139.44,10 150,19.04 160.4,35.92 170.8,57.28 180,79.76 186.8,100 190,120.4 188.64,143.2 183.52,164.8 176.08,181.6 167.76,190 160,185.68 153.12,171.04 146.16,152.56 138.64,136.72 130.08,130 120,136.08 106.48,150.64 89.84,168.16 72.96,183.12 58.72,190 50,186.56 49.52,176.48 55.36,163.12 63.44,149.84 69.68,140 70,134.24 61.36,130.32 46.48,127.28 29.92,124.16 16.24,120 10,115.28 14.4,110.64 26.4,105.36 41.2,98.72 54,90 60,76.8 56,59.6 45.2,42 32.4,27.6 22.4,20 20)) | POLYGON((20 20,19.95 22.59,22.4 27.12,26.75 33.23,32.4 40.56,38.75 48.75,45.2 57.44,51.15 66.27,56 74.88,59.15 82.91,60 90,58.015 96.495,53.52 102.96,47.205 109.365,39.76 115.68,31.875 121.875,24.24 127.92,17.545 133.785,12.48 139.44,9.735 144.855,10 150,13.33 155.125,19.04 160.4,26.71 165.675,35.92 170.8,46.25 175.625,57.28 180,68.59 183.775,79.76 186.8,90.37 188.925,100 190,109.675 189.88,120.4 188.64,131.725 186.46,143.2 183.52,154.375 180,164.8 176.08,174.025 171.94,181.6 167.76,187.075 163.72,190 160,189.535 156.54,185.68 153.12,179.245 149.68,171.04 146.16,161.875 142.5,152.56 138.64,143.905 134.52,136.72 130.08,131.815 125.26,130 120,131.635 113.81,136.08 106.48,142.645 98.37,150.64 89.84,159.375 81.25,168.16 72.96,176.305 65.33,183.12 58.72,187.915 53.49,190 50,189.32 48.715,186.56 49.52,182.14 51.905,176.48 55.36,170 59.375,163.12 63.44,156.26 67.045,149.84 69.68,144.28 70.835,140 70,136.83 66.745,134.24 61.36,132.11 54.415,130.32 46.48,128.75 38.125,127.28 29.92,125.79 22.435,124.16 16.24,122.27 11.905,120 10,117.585 10.95,115.28 14.4,112.995 19.75,110.64 26.4,108.125 33.75,105.36 41.2,102.255 48.15,98.72 54,94.665 58.15,90 60,84.125 59.15,76.8 56,68.475 51.15,59.6 45.2,50.625 38.75,42 32.4,34.175 26.75,27.6 22.4,22.725 19.95,20 20))
ST_ConcaveHull — Beräknar en eventuellt konkav geometri som innehåller alla indatageometrins toppar
geometry ST_ConcaveHull(geometry param_geom, float param_pctconvex, boolean param_allow_holes = false);
Ett konkavt skrov är en (vanligtvis) konkav geometri som innehåller indata och vars hörn är en delmängd av indatans hörn. I det allmänna fallet är det konkava skrovet en polygon. Det konkava skrovet av två eller flera kollinjära punkter är en LineString med två punkter. Det konkava skrovet av en eller flera identiska punkter är en Point. Polygonen kommer inte att innehålla hål om inte det valfria param_allow_holes-argumentet anges som true.
Man kan tänka på ett konkavt skrov som att "krympa ihop" en uppsättning punkter. Detta skiljer sig från det konvexa skrovet, som är mer som att linda ett gummiband runt punkterna. Ett konkavt skrov har i allmänhet en mindre yta och representerar en mer naturlig gräns för inmatningspunkterna.
Param_pctconvex styr den beräknade skrovets konkavitet. Ett värde på 1 ger det konvexa skrovet. Värden mellan 1 och 0 ger skrov med ökande konkavitet. Ett värde på 0 ger ett skrov med maximal konkavitet (men fortfarande en enda polygon). Valet av ett lämpligt värde beror på hur indata ser ut, men ofta ger värden mellan 0,3 och 0,1 rimliga resultat.
![]() | |
Tekniskt sett fastställer |
För punktformiga och linjära inmatningar kommer skrovet att omsluta alla inmatningens punkter. För polygonala indata kommer skrovet att omsluta alla punkter i indata och även alla områden som täcks av indata. Om du vill ha ett punktvis skrov av en polygonal indata, konvertera den först till punkter med ST_Points.
This is not an aggregate function. To compute the concave hull of a set of geometries use ST_Collect (e.g. ST_ConcaveHull(ST_Collect(geom ), 0.80).
Tillgänglighet: 2.0.0
Förbättrad: 3.3.0, inbyggd GEOS-implementering aktiverad för GEOS 3.11+
Concave hull of a MultiPoint.
SELECT ST_ConcaveHull('MULTIPOINT ((10 72),(53 76),(56 66),(63 58),(71 51),(81 48),(91 46),(101 45),(111 46),(121 47),(131 50),(140 55),(145 64),(144 74),(135 80),(125 83),(115 85),(105 87),(95 89),(85 91),(75 93),(65 95),(55 98),(45 102),(37 107),(29 114),(22 122),(19 132),(18 142),(21 151),(27 160),(35 167),(44 172),(54 175),(64 178),(74 180),(84 181),(94 181),(104 181),(114 181),(124 181),(134 179),(144 177),(153 173),(162 168),(171 162),(177 154),(182 145),(184 135),(139 132),(136 142),(128 149),(119 153),(109 155),(99 155),(89 155),(79 153),(69 150),(61 144),(63 134),(72 128),(82 125),(92 123),(102 121),(112 119),(122 118),(132 116),(142 113),(151 110),(161 106),(170 102),(178 96),(185 88),(189 78),(190 68),(189 58),(185 49),(179 41),(171 34),(162 29),(153 25),(143 23),(133 21),(123 19),(113 19),(102 19),(92 19),(82 19),(72 21),(62 22),(52 25),(43 29),(33 34),(25 41),(19 49),(14 58),(21 73),(31 74),(42 74),(173 134),(161 134),(150 133),(97 104),(52 117),(157 156),(94 171),(112 106),(169 73),(58 165),(149 40),(70 33),(147 157),(48 153),(140 96),(47 129),(173 55),(144 86),(159 67),(150 146),(38 136),(111 170),(124 94),(26 59),(60 41),(71 162),(41 64),(88 110),(122 34),(151 97),(157 56),(39 146),(88 33),(159 45),(47 56),(138 40),(129 165),(33 48),(106 31),(169 147),(37 122),(71 109),(163 89),(37 156),(82 170),(180 72),(29 142),(46 41),(59 155),(124 106),(157 80),(175 82),(56 50),(62 116),(113 95),(144 167))',
0.1 );st_astext ----------- POLYGON ((18 142, 21 151, 27 160, 35 167, 44 172, 54 175, 64 178, 74 180, 84 181, 94 181, 104 181, 114 181, 124 181, 134 179, 144 177, 153 173, 162 168, 171 162, 177 154, 182 145, 184 135, 173 134, 161 134, 150 133, 139 132, 136 142, 128 149, 119 153, 109 155, 99 155, 89 155, 79 153, 69 150, 61 144, 63 134, 72 128, 82 125, 92 123, 102 121, 112 119, 122 118, 132 116, 142 113, 151 110, 161 106, 170 102, 178 96, 185 88, 189 78, 190 68, 189 58, 185 49, 179 41, 171 34, 162 29, 153 25, 143 23, 133 21, 123 19, 113 19, 102 19, 92 19, 82 19, 72 21, 62 22, 52 25, 43 29, 33 34, 25 41, 19 49, 14 58, 10 72, 21 73, 31 74, 42 74, 53 76, 56 66, 63 58, 71 51, 81 48, 91 46, 101 45, 111 46, 121 47, 131 50, 140 55, 145 64, 144 74, 135 80, 125 83, 115 85, 105 87, 95 89, 85 91, 75 93, 65 95, 55 98, 45 102, 37 107, 29 114, 22 122, 19 132, 18 142)) (1 row)
Concave hull of a MultiPoint, allowing holes.
SELECT ST_ConcaveHull('MULTIPOINT ((132 64),(114 64),(99 64),(81 64),(63 64),(57 49),(52 36),(46 20),(37 20),(26 20),(32 36),(39 55),(43 69),(50 84),(57 100),(63 118),(68 133),(74 149),(81 164),(88 180),(101 180),(112 180),(119 164),(126 149),(132 131),(139 113),(143 100),(150 84),(157 69),(163 51),(168 36),(174 20),(163 20),(150 20),(143 36),(139 49),(132 64),(99 151),(92 138),(88 124),(81 109),(74 93),(70 82),(83 82),(99 82),(112 82),(126 82),(121 96),(114 109),(110 122),(103 138),(99 151),(34 27),(43 31),(48 44),(46 58),(52 73),(63 73),(61 84),(72 71),(90 69),(101 76),(123 71),(141 62),(166 27),(150 33),(159 36),(146 44),(154 53),(152 62),(146 73),(134 76),(143 82),(141 91),(130 98),(126 104),(132 113),(128 127),(117 122),(112 133),(119 144),(108 147),(119 153),(110 171),(103 164),(92 171),(86 160),(88 142),(79 140),(72 124),(83 131),(79 118),(68 113),(63 102),(68 93),(35 45))',
0.15, true );st_astext ----------- POLYGON ((43 69, 50 84, 57 100, 63 118, 68 133, 74 149, 81 164, 88 180, 101 180, 112 180, 119 164, 126 149, 132 131, 139 113, 143 100, 150 84, 157 69, 163 51, 168 36, 174 20, 163 20, 150 20, 143 36, 139 49, 132 64, 114 64, 99 64, 81 64, 63 64, 57 49, 52 36, 46 20, 37 20, 26 20, 32 36, 35 45, 39 55, 43 69), (88 124, 81 109, 74 93, 83 82, 99 82, 112 82, 121 96, 114 109, 110 122, 103 138, 92 138, 88 124)) (1 row)
Jämförelse av ett konkavt skrov av en polygon med det konkava skrovet av de ingående punkterna. Skrovet respekterar polygonens gräns, medan det punktbaserade skrovet inte gör det.
WITH data(geom) AS (VALUES
('POLYGON ((10 90,39 85,61 79,50 90,80 80,95 55,25 60,90 45,70 16,63 38,60 10,50 30,43 27,30 10,20 20,10 90))'::geometry)
)
SELECT ST_ConcaveHull(geom, 0.1) AS polygon_hull,
ST_ConcaveHull(ST_Points(geom), 0.1) AS points_hull
FROM data;
POLYGON((60 10,50 30,43 27,30 10,20 20,10 90,39 85,50 90,80 80,95 55,90 45,70 16,60 10)) | POLYGON((25 60,10 90,39 85,50 90,80 80,95 55,90 45,70 16,60 10,30 10,20 20,43 27,50 30,63 38,61 79,25 60))
Används med ST_Collect för att beräkna det konkava skrovet av en geometrisk uppsättning.
This example estimates an infected area from point observations.
SELECT disease_type,
ST_ConcaveHull(ST_Collect(obs_pnt), 0.3 ) AS geom
FROM disease_obs
GROUP BY disease_type;
ST_ConvexHull — Beräknar det konvexa skrovet av en geometri.
geometry ST_ConvexHull(geometry geomA);
Beräknar det konvexa skrovet av en geometri. Det konvexa skrovet är den minsta konvexa geometrin som omsluter alla geometrier i indata.
Man kan tänka sig det konvexa skrovet som den geometri som erhålls genom att linda ett gummiband runt en uppsättning geometrier. Detta skiljer sig från ett konkavt skrov som är analogt med att "krympa" geometrierna. Ett konvext skrov används ofta för att bestämma ett påverkat område baserat på en uppsättning punktobservationer.
I det allmänna fallet är den konvexa skrovet en polygon. Det konvexa skrovet av två eller flera kollinjära punkter är en tvåpunkts LineString. Det konvexa skrovet av en eller flera identiska punkter är en Point.
Detta är inte en aggregeringsfunktion. För att beräkna det konvexa skrovet av en uppsättning geometrier, använd ST_Collect för att aggregera dem till en geometrisamling (t.ex. ST_ConvexHull(ST_Collect(geom)).
Utförs av GEOS-modulen
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s2.1.1.3
Denna metod implementerar SQL/MM-specifikationen. SQL-MM IEC 13249-3: 5.1.16
Denna funktion stöder 3d och kommer inte att tappa z-index.
Compute the convex hull of a MultiLineString and a MultiPoint.
SELECT ST_ConvexHull(ST_Collect(ST_GeomFromText('MULTILINESTRING((100 190,10 8),(150 10,20 30))'),
ST_GeomFromText('MULTIPOINT(50 5,150 30,50 10,10 10)')
));st_astext ----------- POLYGON((50 5,10 8,10 10,100 190,150 30,150 10,50 5)) (1 row)
Används med ST_Collect för att beräkna konvexa skrov av geometriska uppsättningar.
This example returns an estimated infected area from point observations.
SELECT d.disease_type,
ST_ConvexHull(ST_Collect(d.geom)) As geom
FROM disease_obs As d
GROUP BY d.disease_type;
ST_DelaunayTriangles — Returnerar Delaunay-trianguleringen av hörnen i en geometri.
geometry ST_DelaunayTriangles(geometry g1, float tolerance = 0.0, int4 flags = 0);
Beräknar Delaunay-trianguleringen av hörnen i indatageometrin. Den valfria toleransen kan användas för att fästa ihop närliggande indatavertikaler, vilket förbättrar robustheten i vissa situationer. Resultatgeometrin avgränsas av den konvexa skrovet av indatapunkterna. Representationen av resultatgeometrin bestäms av flaggkoden:
0 - en GEOMETRYCOLLECTION av triangulära POLYGONER (standard)
1 - en MULTILINESTRING av trianguleringens kanter
2 - En TIN av trianguleringen
Utförs av GEOS-modulen.
Tillgänglighet: 2.1.0
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
Triangulation of the vertices of a polygon and a buffered point.
WITH data AS (
SELECT polygon, ST_Buffer(center, 20) AS point_buffer
FROM (SELECT
'POLYGON((175 150,20 40,50 60,125 100,175 150))'::geometry AS polygon,
'POINT(110 170)'::geometry AS center
) AS input
)
SELECT ST_DelaunayTriangles(ST_Union(polygon, point_buffer)) AS triangles
FROM data;GEOMETRYCOLLECTION(POLYGON((96 184,93 181,96 156,96 184)), POLYGON((96 184,96 156,102 188,96 184)), POLYGON((96 184,102 188,99 187,96 184)), POLYGON((102 188,96 156,99 153,102 188)), POLYGON((102 188,99 153,102 152,102 188)), POLYGON((102 188,102 152,106 190,102 188)), POLYGON((106 190,102 152,106 150,106 190)), POLYGON((106 190,106 150,110 190,106 190)), POLYGON((110 190,106 150,110 150,110 190)), POLYGON((110 190,110 150,118 188,110 190)), POLYGON((110 190,118 188,114 190,110 190)), POLYGON((118 188,110 150,121 153,118 188)), POLYGON((118 188,121 153,121 187,118 188)), POLYGON((121 187,121 153,124 156,121 187)), POLYGON((121 187,124 156,124 184,121 187)), POLYGON((121 187,124 184,175 150,121 187)), POLYGON((175 150,124 184,127 181,175 150)), POLYGON((175 150,127 181,128 178,175 150)), POLYGON((175 150,128 178,130 174,175 150)), POLYGON((175 150,130 174,130 170,175 150)), POLYGON((175 150,130 170,130 166,175 150)), POLYGON((175 150,130 166,128 162,175 150)), POLYGON((175 150,128 162,127 159,175 150)), POLYGON((175 150,127 159,124 156,175 150)), POLYGON((175 150,124 156,125 100,175 150)), POLYGON((125 100,124 156,121 153,125 100)), POLYGON((125 100,121 153,118 152,125 100)), POLYGON((125 100,118 152,114 150,125 100)), POLYGON((125 100,114 150,110 150,125 100)), POLYGON((125 100,110 150,106 150,125 100)), POLYGON((125 100,106 150,102 152,125 100)), POLYGON((125 100,102 152,99 153,125 100)), POLYGON((125 100,99 153,50 60,125 100)), POLYGON((125 100,50 60,20 40,125 100)), POLYGON((20 40,50 60,90 166,20 40)), POLYGON((20 40,90 166,90 170,20 40)), POLYGON((20 40,90 170,90 174,20 40)), POLYGON((20 40,90 174,92 178,20 40)), POLYGON((92 178,90 174,90 170,92 178)), POLYGON((92 178,90 170,92 162,92 178)), POLYGON((92 178,92 162,93 159,92 178)), POLYGON((92 178,93 159,93 181,92 178)), POLYGON((93 181,93 159,96 156,93 181)), POLYGON((96 156,93 159,50 60,96 156)), POLYGON((96 156,50 60,99 153,96 156)), POLYGON((50 60,93 159,92 162,50 60)), POLYGON((50 60,92 162,90 166,50 60)), POLYGON((90 166,92 162,90 170,90 166)), POLYGON((110 150,114 150,121 153,110 150)), POLYGON((121 153,114 150,118 152,121 153)), POLYGON((124 156,127 159,130 166,124 156)), POLYGON((124 156,130 166,128 178,124 156)), POLYGON((124 156,128 178,124 184,124 156)), POLYGON((124 184,128 178,127 181,124 184)), POLYGON((128 178,130 166,130 170,128 178)), POLYGON((128 178,130 170,130 174,128 178)), POLYGON((130 166,127 159,128 162,130 166)))
Triangulation edges returned as a MULTILINESTRING.
WITH data AS (
SELECT polygon, ST_Buffer(center, 20) AS point_buffer
FROM (SELECT
'POLYGON((175 150,20 40,50 60,125 100,175 150))'::geometry AS polygon,
'POINT(110 170)'::geometry AS center
) AS input
)
SELECT ST_DelaunayTriangles(ST_Union(polygon, point_buffer), 0.001, 1) AS triangulation_edges
FROM data;MULTILINESTRING((121 187,175 150),(118 188,121 187),(114 190,118 188),(110 190,114 190),(106 190,110 190),(102 188,106 190),(99 187,102 188),(96 184,99 187),(93 181,96 184),(92 178,93 181),(20 40,92 178),(20 40,125 100),(125 100,175 150),(124 156,125 100),(124 156,175 150),(124 156,127 159),(127 159,175 150),(127 159,128 162),(128 162,175 150),(128 162,130 166),(130 166,175 150),(130 166,130 170),(130 170,175 150),(130 174,130 170),(130 174,175 150),(128 178,130 174),(128 178,175 150),(127 181,128 178),(127 181,175 150),(124 184,127 181),(124 184,175 150),(121 187,124 184),(124 156,124 184),(121 187,124 156),(121 153,124 156),(121 153,121 187),(118 188,121 153),(110 150,121 153),(110 150,118 188),(110 150,110 190),(110 190,118 188),(106 150,110 150),(106 150,110 190),(106 190,106 150),(102 152,106 150),(102 152,106 190),(102 152,102 188),(99 153,102 152),(99 153,102 188),(96 156,99 153),(96 156,102 188),(96 156,96 184),(96 184,102 188),(93 181,96 156),(93 159,96 156),(93 159,93 181),(92 178,93 159),(92 162,93 159),(92 162,92 178),(90 170,92 162),(90 170,92 178),(90 170,90 174),(90 174,92 178),(20 40,90 174),(20 40,90 170),(90 170,90 166),(20 40,90 166),(50 60,90 166),(20 40,50 60),(50 60,125 100),(50 60,99 153),(99 153,125 100),(50 60,96 156),(50 60,93 159),(50 60,92 162),(90 166,92 162),(102 152,125 100),(106 150,125 100),(110 150,125 100),(110 150,114 150),(114 150,125 100),(114 150,118 152),(118 152,125 100),(118 152,121 153),(121 153,125 100),(114 150,121 153),(124 184,128 178),(124 156,128 178),(128 178,130 166),(124 156,130 166),(127 159,130 166),(128 178,130 170))
Triangulation of 42 points forming an L shape.
WITH data AS (
SELECT 'MULTIPOINT(14 14,34 14,54 14,74 14,94 14,114 14,134 14,
150 14,154 14,154 6,134 6,114 6,94 6,74 6,54 6,34 6,
14 6,10 6,8 6,7 7,6 8,6 10,6 30,6 50,6 70,6 90,6 110,6 130,
6 150,6 170,6 190,6 194,14 194,14 174,14 154,14 134,14 114,
14 94,14 74,14 54,14 34,14 14)'::geometry AS l_shape_points
)
SELECT ST_DelaunayTriangles(l_shape_points) AS triangles
FROM data;GEOMETRYCOLLECTION(POLYGON((6 194,6 190,14 194,6 194)), POLYGON((14 194,6 190,14 174,14 194)), POLYGON((14 194,14 174,154 14,14 194)), POLYGON((154 14,14 174,14 154,154 14)), POLYGON((154 14,14 154,150 14,154 14)), POLYGON((154 14,150 14,154 6,154 14)), POLYGON((154 6,150 14,134 6,154 6)), POLYGON((134 6,150 14,134 14,134 6)), POLYGON((134 6,134 14,114 14,134 6)), POLYGON((134 6,114 14,114 6,134 6)), POLYGON((114 6,114 14,94 14,114 6)), POLYGON((114 6,94 14,94 6,114 6)), POLYGON((94 6,94 14,74 14,94 6)), POLYGON((94 6,74 14,74 6,94 6)), POLYGON((74 6,74 14,54 14,74 6)), POLYGON((74 6,54 14,54 6,74 6)), POLYGON((54 6,54 14,34 14,54 6)), POLYGON((54 6,34 14,34 6,54 6)), POLYGON((34 6,34 14,14 14,34 6)), POLYGON((34 6,14 14,14 6,34 6)), POLYGON((14 6,14 14,10 6,14 6)), POLYGON((10 6,14 14,6 10,10 6)), POLYGON((10 6,6 10,7 7,10 6)), POLYGON((10 6,7 7,8 6,10 6)), POLYGON((7 7,6 10,6 8,7 7)), POLYGON((6 10,14 14,6 30,6 10)), POLYGON((6 30,14 14,14 34,6 30)), POLYGON((6 30,14 34,6 50,6 30)), POLYGON((6 50,14 34,14 54,6 50)), POLYGON((6 50,14 54,6 70,6 50)), POLYGON((6 70,14 54,14 74,6 70)), POLYGON((6 70,14 74,6 90,6 70)), POLYGON((6 90,14 74,14 94,6 90)), POLYGON((6 90,14 94,6 110,6 90)), POLYGON((6 110,14 94,14 114,6 110)), POLYGON((6 110,14 114,6 130,6 110)), POLYGON((6 130,14 114,14 134,6 130)), POLYGON((6 130,14 134,6 150,6 130)), POLYGON((6 150,14 134,14 154,6 150)), POLYGON((6 150,14 154,6 170,6 150)), POLYGON((6 170,14 154,14 174,6 170)), POLYGON((6 170,14 174,6 190,6 170)), POLYGON((14 154,14 134,150 14,14 154)), POLYGON((150 14,14 134,134 14,150 14)), POLYGON((134 14,14 134,114 14,134 14)), POLYGON((114 14,14 134,14 114,114 14)), POLYGON((114 14,14 114,94 14,114 14)), POLYGON((94 14,14 114,14 94,94 14)), POLYGON((94 14,14 94,74 14,94 14)), POLYGON((74 14,14 94,14 74,74 14)), POLYGON((74 14,14 74,54 14,74 14)), POLYGON((54 14,14 74,14 54,54 14)), POLYGON((54 14,14 54,34 14,54 14)), POLYGON((34 14,14 54,14 34,34 14)), POLYGON((34 14,14 34,14 14,34 14)))
Exempel med hörnpunkter med Z-värden.
SELECT ST_DelaunayTriangles( 'MULTIPOINT Z(14 14 10,150 14 100,34 6 25,20 10 150)'::geometry);
GEOMETRYCOLLECTION Z (POLYGON Z ((14 14 10,20 10 150,34 6 25,14 14 10)),POLYGON Z ((14 14 10,34 6 25,150 14 100,14 14 10)))
ST_FilterByM — Tar bort hörn baserat på deras M-värde
geometry ST_FilterByM(geometry geom, double precision min, double precision max = null, boolean returnM = false);
Filtrerar bort vertexpunkter baserat på deras M-värde. Returnerar en geometri med endast vertexpunkter som har ett M-värde som är större än eller lika med min-värdet och mindre än eller lika med max-värdet. Om argumentet max-värde utelämnas beaktas endast min-värdet. Om det fjärde argumentet utelämnas kommer m-värdet inte att finnas med i den resulterande geometrin. Om den resulterande geometrin har för få vertexpunkter kvar för sin geometrityp kommer en tom geometri att returneras. I en geometrisamling kommer geometrier som inte har tillräckligt med punkter att utelämnas i tysthet.
Denna funktion är främst avsedd att användas tillsammans med ST_SetEffectiveArea. ST_EffectiveArea anger den effektiva arean för en vertex i dess m-värde. Med ST_FilterByM är det möjligt att få en förenklad version av geometrin utan några beräkningar, bara genom att filtrera
![]() | |
Det finns en skillnad i vad ST_SimplifyVW returnerar när inte tillräckligt många punkter uppfyller kriterierna jämfört med ST_FilterByM. ST_SimplifyVW returnerar geometrin med tillräckligt många punkter medan ST_FilterByM returnerar en tom geometri |
![]() | |
Observera att den returnerade geometrin kan vara ogiltig |
![]() | |
Denna funktion returnerar alla dimensioner, inklusive Z- och M-värden |
Tillgänglighet: 2.5.0
En linestrings är filtrerad
SELECT ST_FilterByM(geom, 30) simplified
FROM (SELECT ST_SetEffectiveArea('LINESTRING(5 2,3 8,6 20,7 25,10 10)'::geometry) geom) As foo;LINESTRING(5 2,7 25,10 10)
ST_GeneratePoints — Genererar en multipoint av slumpmässiga punkter som ingår i en polygon eller multipolygon.
geometry ST_GeneratePoints(geometry g, integer npoints, integer seed = 0);
ST_GeneratePoints genererar en multipunkt som består av ett givet antal pseudoslumpmässiga punkter som ligger inom inmatningsområdet. Det valfria fröet används för att återskapa en deterministisk sekvens av punkter och måste vara större än noll.
Tillgänglighet: 2.3.0
Förbättrad: 3.0.0, tillagd parameter för utsäde
Generate 12 points inside a buffered LineString using the deterministic seed 1996.
WITH source AS (
SELECT ST_Buffer(ST_GeomFromText('LINESTRING(50 50,150 150,150 50)'),
10, 'endcap=round join=round') AS geom
)
SELECT geom AS area,
ST_GeneratePoints(geom, 12, 1996) AS points
FROM source;POLYGON((142.929 157.071,144.444 158.315,146.173 159.239,148.049 159.808,150 160,151.951 159.808,153.827 159.239,155.556 158.315,157.071 157.071,158.315 155.556,159.239 153.827,159.808 151.951,160 150,160 50,159.808 48.049,159.239 46.173,158.315 44.444,157.071 42.929,155.556 41.685,153.827 40.761,151.951 40.192,150 40,148.049 40.192,146.173 40.761,144.444 41.685,142.929 42.929,141.685 44.444,140.761 46.173,140.192 48.049,140 50,140 125.858,57.071 42.929,55.556 41.685,53.827 40.761,51.951 40.192,50 40,48.049 40.192,46.173 40.761,44.444 41.685,42.929 42.929,41.685 44.444,40.761 46.173,40.192 48.049,40 50,40.192 51.951,40.761 53.827,41.685 55.556,42.929 57.071,142.929 157.071)) | MULTIPOINT((97.546 111.15),(155.206 69.56),(101.94 114.818),(90.308 91.125),(151.257 106.401),(143.12 120.461),(152.952 146.697),(119.774 123.985),(148.672 40.92),(54.376 45.337),(150.667 88.153),(129.634 120.578))
Givet en tabell med polygoner s, returnera 12 individuella punkter per polygon. Resultaten kommer att vara olika varje gång du kör.
SELECT s.id, dp.path[1] AS pt_id, dp.geom FROM s, ST_DumpPoints(ST_GeneratePoints(s.geom, 12)) AS dp;
Generate dot-density points from a polygon table, using the absolute value of an attribute as the number of points and keeping the sign of the attribute for styling.
SELECT z.id,
CASE WHEN z.count_delta < 0 THEN -1 ELSE 1 END AS sign,
dp.path[1] AS pt_id,
dp.geom
FROM zones AS z
CROSS JOIN LATERAL ST_DumpPoints(
ST_GeneratePoints(z.geom, abs(z.count_delta)::integer, z.id + 1)
) AS dp
WHERE z.count_delta <> 0;ST_GeometricMedian — Returnerar den geometriska medianen för en MultiPoint.
geometry ST_GeometricMedian ( geometry geom, float8 tolerance = NULL, int max_iter = 10000, boolean fail_if_not_converged = false);
Beräknar den ungefärliga geometriska medianen i en MultiPoint-geometri med hjälp av Weiszfeld-algoritmen. Den geometriska medianen är den punkt som minimerar summan av avstånden till indatapunkterna. Den ger ett centralitetsmått som är mindre känsligt för avvikande punkter än centroiden (masscentrum).
Algoritmen itererar tills avståndsförändringen mellan på varandra följande iterationer är mindre än den angivna toleransparametern. Om detta villkor inte har uppfyllts efter max_iterations iterationer, producerar funktionen ett fel och avslutas, såvida inte fail_if_not_converged är satt till false (standard).
Om inget toleransargument anges beräknas toleransvärdet baserat på omfattningen av indatageometrin.
Om den finns tolkas M-värdena för inmatningspunkterna som deras relativa vikter.
Tillgänglighet: 2.3.0
Förbättrad: 2.5.0 Lagt till stöd för M som vikt för punkter.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder M-koordinater.
Compare the geometric median and centroid of a MultiPoint.
WITH test AS ( SELECT 'MULTIPOINT((10 10),(10 40),(40 10),(190 190))'::geometry geom) SELECT ST_Centroid(geom) centroid, ST_GeometricMedian(geom) median FROM test;
centroid | median --------------------+---------------------------------------- POINT(62.5 62.5) | POINT(25.01778421249728 25.01778421249728) (1 row)
ST_LineMerge — Returnerar de linjer som bildas genom att sy ihop en MultiLineString.
geometry ST_LineMerge(geometry amultilinestring);
geometry ST_LineMerge(geometry amultilinestring, boolean directed);
Returnerar en LineString eller MultiLineString som bildats genom att sammanfoga linjeelementen i en MultiLineString. Linjer sammanfogas vid sina ändpunkter i 2-vägs korsningar. Linjer sammanfogas inte över korsningar med 3-vägs eller högre grad.
Om directed är TRUE kommer ST_LineMerge inte att ändra punktordningen inom LineStrings, så linjer med motsatta riktningar kommer inte att slås samman
![]() | |
Används endast med MultiLineString/LineStrings. Andra geometrityper returnerar en tom GeometryCollection |
Utförs av GEOS-modulen.
Förbättrad: 3.3.0 acceptera en riktad parameter.
Kräver GEOS >= 3.11.0 för att använda den riktade parametern.
Tillgänglighet: 1.1.0
![]() | |
Denna funktion tar bort M-dimensionen. |
Nodes with cardinality 2 are merged away.
SELECT ST_LineMerge('MULTILINESTRING((10 160,60 120),(120 140,60 120),(120 140,180 120))'
);LINESTRING(10 160,60 120,120 140,180 120)
Linjerna är inte sammanfogade över korsningar med grad > 2.
SELECT ST_LineMerge('MULTILINESTRING((10 160,60 120),(120 140,60 120),(120 140,180 120),(100 180,120 140))'
);MULTILINESTRING((10 160,60 120,120 140),(100 180,120 140),(120 140,180 120))
Om sammanslagning inte är möjlig på grund av linjer som inte berör varandra returneras den ursprungliga MultiLineString.
SELECT ST_LineMerge('MULTILINESTRING((-29 -27,-30 -29.7,-36 -31,-45 -33),(-45.2 -33.2,-46 -32))'
);MULTILINESTRING((-45.2 -33.2,-46 -32),(-29 -27,-30 -29.7,-36 -31,-45 -33))
Lines with opposite directions are not merged if directed is TRUE.
SELECT ST_LineMerge('MULTILINESTRING((60 30,10 70),(120 50,60 30),(120 50,180 30))',
TRUE);MULTILINESTRING((120 50,60 30,10 70),(120 50,180 30))
SELECT ST_LineMerge('MULTILINESTRING((-29 -27 11,-30 -29.7 10,-36 -31 5,-45 -33 6),(-29 -27 12,-30 -29.7 5),(-45 -33 1,-46 -32 11))'
);LINESTRING Z (-30 -29.7 5,-29 -27 11,-30 -29.7 10,-36 -31 5,-45 -33 1,-46 -32 11)
ST_MaximumInscribedCircle — Beräknar den största cirkeln inom en geometri.
(geometry, geometry, double precision) ST_MaximumInscribedCircle(geometry geom);
Hittar den största cirkeln som ingår i en (multi)polygon, eller som inte överlappar några linjer och punkter. Returnerar en post med fält:
center - cirkelns mittpunkt
nearest - en punkt på geometrin som ligger närmast centrum
radie - cirkelns radie
För polygonala indata skrivs cirkeln in i begränsningsringarna, med de inre ringarna som gränser. För linjära och punktformade indata skrivs cirkeln in i indatats konvexa skrov, med indatans linjer och punkter som ytterligare gränser.
Tillgänglighet: 3.1.0.
Kräver GEOS >= 3.9.0.
Maximum inscribed circle of a polygon. Center, nearest point, radius, circle, and radius line are returned.
WITH mic AS (
SELECT * FROM ST_MaximumInscribedCircle(
'POLYGON ((40 180,110 160,180 180,180 120,140 90,160 40,80 10,70 40,20 50,40 180),
(60 140,50 90,90 140,60 140))')
)
SELECT round(radius::numeric, 3) AS radius,
ST_SnapToGrid(center, 1) AS center,
ST_SnapToGrid(nearest, 1) AS nearest,
ST_SnapToGrid(ST_Buffer(center, radius), 1) AS circle,
ST_SnapToGrid(ST_MakeLine(center, nearest), 1) AS radius_line
FROM mic;-[ RECORD 1 ]----- radius | 45.189 center | POINT(97 76) nearest | POINT(62 105) circle | POLYGON((142 76,141 68,139 59,135 51,129 44,122 39,114 35,106 32,97 31,88 32,80 35,72 39,65 44,59 51,55 59,53 68,52 76,53 85,55 94,59 101,65 108,72 114,80 118,88 121,97 122,106 121,114 118,122 114,129 108,135 101,139 94,141 85,142 76)) radius_line | LINESTRING(97 76,62 105)
Maximum inscribed circle of a MultiLineString.
WITH mic AS (
SELECT * FROM ST_MaximumInscribedCircle(
'MULTILINESTRING((100 40,10 150),(10 160,100 150),(190 150,80 40))')
)
SELECT round(radius::numeric, 3) AS radius,
ST_SnapToGrid(center, 1) AS center,
ST_SnapToGrid(nearest, 1) AS nearest,
ST_SnapToGrid(ST_Buffer(center, radius), 1) AS circle,
ST_SnapToGrid(ST_MakeLine(center, nearest), 1) AS radius_line
FROM mic;-[ RECORD 1 ]----- radius | 39.924 center | POINT(94 110) nearest | POINT(63 85) circle | POLYGON((134 110,133 103,131 95,127 88,122 82,116 77,109 74,102 71,94 71,86 71,79 74,72 77,66 82,61 88,57 95,55 103,54 110,55 118,57 126,61 133,66 139,72 144,79 147,86 150,94 150,102 150,109 147,116 144,122 139,127 133,131 126,133 118,134 110)) radius_line | LINESTRING(94 110,63 85)
ST_LargestEmptyCircle — Beräknar den största cirkeln som inte överlappar en geometri.
(geometry, geometry, double precision) ST_LargestEmptyCircle(geometry geom, double precision tolerance=0.0, geometry boundary=POINT EMPTY);
Finner den största cirkeln som inte överlappar en uppsättning punkt- och linjehinder. (Polygonala geometrier kan inkluderas som hinder, men endast deras begränsningslinjer används) Cirkelns centrum måste ligga innanför en polygonal gräns, vilken som standard är det konvexa skrovet av indatageometrin. Cirkelns centrum är den punkt innanför gränsen som har det längsta avståndet från hindren. Själva cirkeln består av mittpunkten och en närmaste punkt som ligger på ett hinder som bestämmer cirkelns radie.
Cirkelns centrum bestäms med en given noggrannhet som specificeras av en avståndstolerans, med hjälp av en iterativ algoritm. Om noggrannhetsavståndet inte specificeras används en rimlig standard.
Returnerar en post med fält:
center - cirkelns mittpunkt
nearest - en punkt på geometrin som ligger närmast centrum
radie - cirkelns radie
För att hitta den största tomma cirkeln i det inre av en polygon, se ST_MaximumInscribedCircle.
Tillgänglighet: 3.4.0.
Kräver GEOS >= 3.9.0.
Largest empty circle within a set of lines.
WITH obstacles(geom) AS (VALUES ('MULTILINESTRING (
(10 100,60 180,130 150,190 160),
(20 50,70 70,90 20,110 40),
(160 30,100 100,180 100))'::geometry)),
circle AS (
SELECT result.*
FROM obstacles
CROSS JOIN LATERAL ST_LargestEmptyCircle(obstacles.geom) AS result
)
SELECT round(radius::numeric, 6) AS radius,
ST_SnapToGrid(center, 1) AS center,
ST_SnapToGrid(nearest, 1) AS nearest,
ST_SnapToGrid(ST_MakeLine(center, nearest), 1) AS radius_line,
ST_SnapToGrid(ST_Buffer(center, radius), 1) AS circle
FROM circle;-[ RECORD 1 ]----- radius | 39.260545 center | POINT(62 108) nearest | POINT(70 70) radius_line | LINESTRING(62 108,70 70) circle | POLYGON((101 108,100 101,98 93,94 87,89 81,83 76,77 72,69 70,62 69,54 70,47 72,40 76,34 81,29 87,25 93,23 101,22 108,23 116,25 123,29 130,34 136,40 141,47 145,54 147,62 148,69 147,77 145,83 141,89 136,94 130,98 123,100 116,101 108))
Largest empty circle within a set of points, constrained to lie in a polygon. The constraint polygon boundary is included both as an obstacle and as the constraint for the circle center.
WITH inputs(points, boundary) AS (VALUES (
'MULTIPOINT ((70 50),(60 130),(130 150),(80 90))'::geometry,
'POLYGON ((90 190,10 100,60 10,190 40,120 100,190 180,90 190))'::geometry
)),
circle AS (
SELECT result.*
FROM inputs
CROSS JOIN LATERAL ST_LargestEmptyCircle(
ST_Collect(points, boundary), 0, boundary
) AS result
)
SELECT round(radius::numeric, 6) AS radius,
ST_SnapToGrid(center, 1) AS center,
ST_SnapToGrid(nearest, 1) AS nearest,
ST_SnapToGrid(ST_MakeLine(center, nearest), 1) AS radius_line,
ST_SnapToGrid(ST_Buffer(center, radius), 1) AS circle
FROM circle;-[ RECORD 1 ]----- radius | 19.903876 center | POINT(97 100) nearest | POINT(80 90) radius_line | LINESTRING(97 100,80 90) circle | POLYGON((117 100,117 96,116 92,114 89,111 86,108 83,105 82,101 80,97 80,93 80,90 82,86 83,83 86,81 89,79 92,78 96,77 100,78 104,79 108,81 111,83 114,86 116,90 118,93 119,97 120,101 119,105 118,108 116,111 114,114 111,116 108,117 104,117 100))
ST_MinimumBoundingCircle — Returnerar den minsta cirkelpolygonen som innehåller en geometri.
geometry ST_MinimumBoundingCircle(geometry geomA, integer num_segs_per_qt_circ=48);
Returnerar den minsta cirkelpolygonen som innehåller en geometri.
![]() | |
Begränsningscirkeln approximeras av en polygon med en standard på 48 segment per kvartscirkel. Eftersom polygonen är en approximation av den minsta begränsningscirkeln kan det hända att vissa punkter i indatageometrin inte ryms inom polygonen. Approximationen kan förbättras genom att öka antalet segment. För tillämpningar där en approximation inte är lämplig kan ST_MinimumBoundingRadius användas. |
Använd med ST_Collect för att få fram den minsta begränsningscirkeln för en uppsättning geometrier.
För att beräkna två punkter som ligger på den minsta cirkeln (den "maximala diametern") använder du ST_LongestLine.
Förhållandet mellan en polygons area dividerat med arean av dess minsta begränsningscirkel kallas Reock compactness score.
Utförs av GEOS-modulen.
Tillgänglighet: 1.4.0
SELECT d.disease_type, ST_MinimumBoundingCircle(ST_Collect(d.geom)) As geom FROM disease_obs As d GROUP BY d.disease_type;
Minimum bounding circle of a point and linestring, using 8 segments to approximate a quarter circle.
SELECT ST_MinimumBoundingCircle(ST_Collect('LINESTRING(55 75,125 150)',
ST_Point(20, 80)), 8
) As wktmbc;POLYGON((72.5 178.4024474346694,84.86920388664029 177.18418718546332,96.76306620464646 173.57622349601382,107.72451249529237 167.71720838753708,117.33230052487836 159.83230052487838,125.21720838753708 150.22451249529237,131.07622349601382 139.26306620464646,134.68418718546332 127.3692038866403,135.9024474346694 115,134.68418718546332 102.63079611335971,131.07622349601382 90.73693379535354,125.21720838753708 79.77548750470766,117.33230052487838 70.16769947512164,107.72451249529237 62.282791612462916,96.76306620464648 56.42377650398619,84.86920388664032 52.815812814536685,72.50000000000001 51.59755256533059,60.13079611335969 52.815812814536685,48.236933795353536 56.42377650398618,37.27548750470765 62.28279161246291,27.667699475121637 70.16769947512162,19.782791612462923 79.77548750470763,13.923776503986204 90.7369337953535,10.315812814536692 102.63079611335968,9.097552565330588 114.99999999999999,10.315812814536685 127.3692038866403,13.923776503986197 139.2630662046465,19.78279161246291 150.22451249529234,27.667699475121623 159.83230052487835,37.275487504707634 167.71720838753708,48.236933795353494 173.5762234960138,60.13079611335967 177.18418718546332,72.5 178.4024474346694))
ST_MinimumBoundingRadius — Returnerar mittpunkten och radien för den minsta cirkeln som innehåller en geometri.
(geometry, double precision) ST_MinimumBoundingRadius(geometry geom);
Beräknar mittpunkt och radie för den minsta cirkel som innehåller en geometri. Returnerar en post med fält:
center - cirkelns mittpunkt
radie - cirkelns radie
Använd med ST_Collect för att få fram den minsta begränsningscirkeln för en uppsättning geometrier.
För att beräkna två punkter som ligger på den minsta cirkeln (den "maximala diametern") använder du ST_LongestLine.
Tillgänglighet - 2.3.0
SELECT center, radius FROM ST_MinimumBoundingRadius('POLYGON((26426 65078,26531 65242,26075 65136,26096 65427,26426 65078))');st_astext | radius ------------------------------------------+------------------ POINT(26284.84180271327 65267.114509082545) | 247.43604559140655
ST_OrientedEnvelope — Returnerar en rektangel med minsta yta som innehåller en geometri.
geometry ST_OrientedEnvelope( geometry geom );
Returnerar den roterade rektangel med minsta area som omsluter en geometri. Observera att det kan finnas mer än en sådan rektangel. Kan returnera en Point eller LineString i händelse av degenererade indata.
Tillgänglighet: 2.5.0.
Kräver GEOS >= 3.6.0.
SELECT ST_OrientedEnvelope('MULTIPOINT ((0 0),(-1 -1),(3 2))');POLYGON((3 2,-1 -1,-1.12 -0.84,2.88 2.16,3 2))
Oriented envelope of a Point and LineString.
SELECT ST_OrientedEnvelope(ST_Collect('LINESTRING(55 75,125 150)',
ST_Point(20, 80))
) As wktenv;POLYGON((20 80,125 150,138.0769230769241 130.38461538461573,33.07692307692291 60.384615384615195,20 80))
ST_OffsetCurve — Returnerar en förskjuten linje på ett givet avstånd och sida från en inmatad linje.
geometry ST_OffsetCurve(geometry line, float signed_distance, text style_parameters='');
Returnerar en offsetlinje på ett givet avstånd och sida från en indatalinje. Alla punkter i de returnerade geometrierna ligger inte längre bort än det angivna avståndet från indatageometrin. Användbar för att beräkna parallella linjer kring en mittlinje.
För positivt avstånd är förskjutningen på vänster sida om inmatningsraden och behåller samma riktning. För ett negativt avstånd är den på höger sida och i motsatt riktning.
Avståndsenheter mäts i enheter i det spatiala referenssystemet.
Observera att utdata kan vara MULTILINESTRING eller EMPTY för vissa pusselformade indatageometrier.
Den valfria tredje parametern gör det möjligt att ange en lista med blankseparerade nyckel=värde-par för att justera operationer enligt följande:
'quad_segs=#' : antal segment som används för att approximera en kvartscirkel (standardvärde 8).
'join=round|mitre|bevel' : fogningsstil (standard är "round"). "Miter" accepteras också som synonym för "mitre".
'mitre_limit=#.#' : gräns för mitraförhållande (påverkar endast mitrad fogning). 'miter_limit' accepteras också som en synonym till 'mitre_limit'.
Utförs av GEOS-modulen.
Beteendet ändrades i GEOS 3.11 så att offsetkurvorna nu har samma riktning som indatalinjen, för både positiva och negativa offsets.
Tillgänglighet: 2.0
Förbättrad: 2.5 - stöd för GEOMETRYCOLLECTION och MULTILINESTRING har lagts till
![]() | |
Denna funktion ignorerar Z-dimensionen. Den ger alltid ett 2D-resultat även när den används på en 3D-geometri. |
Compute an open buffer around roads.
SELECT ST_Union(
ST_OffsetCurve(f.geom, f.width/2, 'quad_segs=4 join=round'),
ST_OffsetCurve(f.geom, -f.width/2, 'quad_segs=4 join=round')
) as track
FROM someroadstable;
Offset 15 units with quad_segs=4 join=round.
SELECT ST_OffsetCurve(
ST_GeomFromText('LINESTRING(164 16,144 16,124 16,104 16,84 16,64 16,
44 16,24 16,20 16,18 16,17 17,
16 18,16 20,16 40,16 60,16 80,16 100,
16 120,16 140,16 160,16 180,16 195)'),
15, 'quad_segs=4 join=round');LINESTRING(164 1,18 1,15.073645169758077 1.288220793951544,
12.259748514523654 2.141807012330698,9.66644650470597 3.527955815461818,
7.393398282201788 5.393398282201788,5.393398282201788 7.393398282201788,
3.527955815461818 9.66644650470597,2.141807012330696 12.259748514523654,
1.288220793951544 15.073645169758075,1 18,1 195)Offset -15 units with quad_segs=4 join=round.
SELECT ST_OffsetCurve(
geom,
-15,
'quad_segs=4 join=round') As notsocurvy
FROM ST_GeomFromText('LINESTRING(164 16,144 16,124 16,104 16,84 16,64 16,
44 16,24 16,20 16,18 16,17 17,
16 18,16 20,16 40,16 60,16 80,16 100,
16 120,16 140,16 160,16 180,16 195)') As geom;LINESTRING(164 31,31 31,31 195)
Apply two negative offsets to obtain a smoother curve; the distances combine to -45 units.
SELECT ST_OffsetCurve(
ST_OffsetCurve(
geom,
-30,
'quad_segs=4 join=round'),
-15,
'quad_segs=4 join=round') As morecurvy
FROM ST_GeomFromText('LINESTRING(164 16,144 16,124 16,104 16,84 16,64 16,
44 16,24 16,20 16,18 16,17 17,
16 18,16 20,16 40,16 60,16 80,16 100,
16 120,16 140,16 160,16 180,16 195)') As geom;LINESTRING(164 61,61 61,61 195)
Collect the positive offset and the double-offset to produce parallel curves.
SELECT ST_Collect(
ST_OffsetCurve(geom, 15, 'quad_segs=4 join=round'),
ST_OffsetCurve(
ST_OffsetCurve(
geom,
-30,
'quad_segs=4 join=round'),
-15,
'quad_segs=4 join=round')
) As parallel_curves
FROM ST_GeomFromText('LINESTRING(164 16,144 16,124 16,104 16,84 16,64 16,
44 16,24 16,20 16,18 16,17 17,
16 18,16 20,16 40,16 60,16 80,16 100,
16 120,16 140,16 160,16 180,16 195)') As geom;MULTILINESTRING((164 1,18 1,15.073645169758077 1.288220793951544, 12.259748514523654 2.141807012330698,9.66644650470597 3.527955815461818, 7.393398282201788 5.393398282201788,5.393398282201788 7.393398282201788, 3.527955815461818 9.66644650470597,2.141807012330696 12.259748514523654, 1.288220793951544 15.073645169758075,1 18,1 195),(164 61,61 61,61 195))
Offset 15 units with a bevel join.
SELECT ST_OffsetCurve(
ST_GeomFromText('LINESTRING(164 16,144 16,124 16,104 16,84 16,64 16,
44 16,24 16,20 16,18 16,17 17,
16 18,16 20,16 40,16 60,16 80,16 100,
16 120,16 140,16 160,16 180,16 195)'),
15, 'quad_segs=4 join=bevel');LINESTRING(164 1,18 1,7.393398282201788 5.393398282201788,
5.393398282201788 7.393398282201788,1 18,1 195)Collect offsets on both sides using a mitre join and a mitre limit of 2.2.
SELECT ST_Collect(
ST_OffsetCurve(geom, 15, 'quad_segs=4 join=mitre mitre_limit=2.2'),
ST_OffsetCurve(geom, -15, 'quad_segs=4 join=mitre mitre_limit=2.2')
)
FROM ST_GeomFromText('LINESTRING(164 16,144 16,124 16,104 16,84 16,64 16,
44 16,24 16,20 16,18 16,17 17,
16 18,16 20,16 40,16 60,16 80,16 100,
16 120,16 140,16 160,16 180,16 195)') As geom;MULTILINESTRING((164 1,11.786796564403577 1,1 11.786796564403577,1 195),
(164 31,31 31,31 195))ST_PointOnSurface — Beräknar en punkt som garanterat ligger i en polygon eller på en geometri.
geometry ST_PointOnSurface(geometry g1);
Returnerar en POINT som garanterat ligger i det inre av en yta(POLYGON, MULTIPOLYGON och CURVEPOLYGON). I PostGIS fungerar denna funktion även på linje- och punktgeometrier.
Denna metod implementerar OGC:s implementeringsspecifikation för enkla funktioner för SQL 1.1. s3.2.14.2 // s3.2.18.2
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3: 8.1.5, 9.5.6. I specifikationerna definieras ST_PointOnSurface endast för ytgeometrier. PostGIS utökar funktionen för att stödja alla vanliga geometrityper. Andra databaser (Oracle, DB2, ArcSDE) verkar endast stödja denna funktion för ytor. SQL Server 2008 stöder alla vanliga geometrityper.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Point on surface of a MultiPoint.
SELECT ST_PointOnSurface( 'MULTIPOINT (8 24,10 92,12 154,17 68,28 10,29 52,29 84,55 50,56 24,131 14,160 180,189 180)');
POINT(55 50)
Point on surface of a LineString.
SELECT ST_PointOnSurface( 'LINESTRING (190 160,10 190,40 90,20 70,10 10,30 40,30 10,110 40,70 10,110 10,140 40,140 10,160 30,180 10)');
POINT(40 90)
Point on surface of a Polygon.
SELECT ST_PointOnSurface( 'POLYGON ((190 190,10 190,10 10,190 10,190 20,160 30,60 30,60 130,190 140,190 190))');
POINT(35 80)
Point on surface of the highest-dimension components of a GeometryCollection.
SELECT ST_PointOnSurface(
'GEOMETRYCOLLECTION (POLYGON ((190 170,180 100,80 140,80 160,130 160,110 180,110 190,180 180,190 170)),
LINESTRING (80 120,120 20,140 70,150 30,180 50,190 10),
MULTIPOINT (19 150,22 49,30 13,32 101,45 35,67 88,75 16))');POINT(133.571 150)
SELECT ST_PointOnSurface('LINESTRING(0 5 1,0 0 1,0 10 2)');st_asewkt -------------- POINT(0 0 1) (1 row)
Exempel på detta: Resultatet av ST_PointOnSurface ligger garanterat inom polygoner, medan den punkt som beräknats av ST_Centroid kan ligga utanför.
SELECT ST_PointOnSurface(geom) AS pt_on_surf, ST_Centroid(geom) AS centroid
FROM (SELECT 'POLYGON ((130 120,120 190,30 140,50 20,190 20,
170 100,90 60,90 130,130 120))'::geometry AS geom) AS t;pt_on_surf | centroid -----------------+--------------------------------------------- POINT(62.5 110) | POINT(100.18264840182648 85.11415525114155)
ST_Polygonize — Beräknar en samling polygoner som bildas av linjerna i en uppsättning geometrier.
geometry ST_Polygonize(geometry set geomfield);
geometry ST_Polygonize(geometry[] geom_array);
Skapar en GeometryCollection som innehåller de polygoner som bildas av linjeverket i en uppsättning geometrier. Om det inmatade linjeverket inte bildar några polygoner returneras en tom GeometryCollection.
Denna funktion skapar polygoner som täcker alla avgränsade områden. Om resultatet är avsett att bilda en giltig polygongeometri, använd ST_BuildArea för att förhindra att hål fylls.
![]() | |
Inmatningsgeometrin måste vara korrekt nodad för att denna funktion ska fungera korrekt. För att säkerställa att inmatningen är nodad använder du ST_Node på inmatningsgeometrin innan du polygoniserar. |
![]() | |
GeometryCollections kan vara svåra att hantera med externa verktyg. Använd ST_Dump för att konvertera det polygoniserade resultatet till separata polygoner. |
Utförs av GEOS-modulen.
Tillgänglighet: 1.0.0RC1
Polygonize a set of input lines.
WITH data(geom) AS (
VALUES
('LINESTRING (180 40,30 20,20 90)'::geometry),
('LINESTRING (180 40,160 160)'::geometry),
('LINESTRING (80 60,120 130,150 80)'::geometry),
('LINESTRING (80 60,150 80)'::geometry),
('LINESTRING (20 90,70 70,80 130)'::geometry),
('LINESTRING (80 130,160 160)'::geometry),
('LINESTRING (20 90,20 160,70 190)'::geometry),
('LINESTRING (70 190,80 130)'::geometry),
('LINESTRING (70 190,160 160)'::geometry)
)
SELECT ST_Polygonize(geom)
FROM data;GEOMETRYCOLLECTION(POLYGON((180 40,30 20,20 90,70 70,80 130,160 160,180 40),(150 80,120 130,80 60,150 80)), POLYGON((80 60,120 130,150 80,80 60)), POLYGON((80 130,70 70,20 90,20 160,70 190,80 130)), POLYGON((160 160,80 130,70 190,160 160)))
Polygonizing two polygon coverages and transferring attributes to the resultants:
WITH poly_a(id, geom) AS (VALUES
('a1', 'POLYGON ((0 0, 4 0, 4 4, 0 4, 0 0))'::geometry),
('a2', 'POLYGON ((4 0, 8 0, 8 4, 4 4, 4 0))'::geometry)
),
poly_b(id, geom) AS (VALUES
('b1', 'POLYGON ((0 0, 8 0, 8 2, 0 2, 0 0))'::geometry),
('b2', 'POLYGON ((0 2, 8 2, 8 4, 0 4, 0 2))'::geometry)
),
lines AS (
SELECT ST_Boundary(geom) AS geom FROM poly_a
UNION ALL
SELECT ST_Boundary(geom) FROM poly_b
),
noded AS (
SELECT ST_UnaryUnion(ST_Collect(geom)) AS geom FROM lines
),
cells AS (
SELECT (ST_Dump(ST_Polygonize(geom))).geom AS geom FROM noded
)
SELECT a.id AS id_a,
b.id AS id_b,
c.geom AS geom
FROM cells AS c
LEFT JOIN poly_a AS a ON ST_Within(ST_PointOnSurface(c.geom), a.geom)
LEFT JOIN poly_b AS b ON ST_Within(ST_PointOnSurface(c.geom), b.geom)
WHERE a.id IS NOT NULL OR b.id IS NOT NULL
ORDER BY id_a, id_b;id_a | id_b | geom ------+------+-------------------------------- a1 | b1 | POLYGON((4 0,0 0,0 2,4 2,4 0)) a1 | b2 | POLYGON((4 4,4 2,0 2,0 4,4 4)) a2 | b1 | POLYGON((4 0,4 2,8 2,8 0,4 0)) a2 | b2 | POLYGON((4 2,4 4,8 4,8 2,4 2))
Polygonisera en tabell med linestrings:
SELECT ST_Polygonize(geom_4269) As geomtextrep FROM (SELECT geom_4269 FROM ma.suffolk_edges) As foo;
geomtextrep ------------- SRID=4269;GEOMETRYCOLLECTION(POLYGON((-71.040878 42.285678,-71.040943 42.2856,-71.04096 42.285752,-71.040878 42.285678)), POLYGON((-71.17166 42.353675,-71.172026 42.354044,-71.17239 42.354358,-71.171794 42.354971,-71.170511 42.354855, -71.17112 42.354238,-71.17166 42.353675))) (1 row)
Use ST_Dump to dump out the polygonize geoms into individual polygons.
SELECT (ST_Dump(t.polycoll)).geom AS geomtextrep
FROM (SELECT ST_Polygonize(geom_4269) AS polycoll
FROM (SELECT geom_4269 FROM ma.suffolk_edges)
As foo) AS t;
geomtextrep ------------- SRID=4269;POLYGON((-71.040878 42.285678,-71.040943 42.2856,-71.04096 42.285752, -71.040878 42.285678)) SRID=4269;POLYGON((-71.17166 42.353675,-71.172026 42.354044,-71.17239 42.354358, -71.171794 42.354971,-71.170511 42.354855,-71.17112 42.354238,-71.17166 42.353675)) (2 rows)
ST_ReducePrecision — Returnerar en giltig geometri med punkter som avrundats till en rutnätstolerans.
geometry ST_ReducePrecision(geometry g, float8 gridsize);
Returnerar en giltig geometri där alla punkter har avrundats till den angivna rutnätstoleransen och där objekt under toleransen har tagits bort.
Till skillnad från ST_SnapToGrid kommer den returnerade geometrin att vara giltig, utan självskärande ringar eller kollapsade komponenter.
Precisionsreduktion kan användas för att:
matcha koordinatprecisionen med datanoggrannheten
minska antalet koordinater som behövs för att representera en geometri
säkerställa giltig geometriutdata till format som använder lägre precision (t.ex. textformat som WKT, GeoJSON eller KML när antalet decimaler i utdata är begränsat).
exportera giltig geometri till system som använder lägre eller begränsad precision (t.ex. SDE, Oracle toleransvärde)
Tillgänglighet: 3.1.0.
Kräver GEOS >= 3.9.0.
SELECT ST_ReducePrecision('POINT(1.412 19.323)', 0.1);POINT(1.4 19.3)
SELECT ST_ReducePrecision('POINT(1.412 19.323)', 1.0);POINT(1 19)
SELECT ST_ReducePrecision('POINT(1.412 19.323)', 10);POINT(0 20)
Precisionsreducering kan minska antalet toppar
SELECT ST_ReducePrecision('LINESTRING (10 10,19.6 30.1,20 30,20.3 30,40 40)', 1);LINESTRING (10 10, 20 30, 40 40)
Precisionsreducering delar upp polygoner om det behövs för att säkerställa validitet
WITH data(geom) AS (
VALUES ('POLYGON ((10 10,60 60.1,70 30,40 40,50 10,10 10))'::geometry)
)
SELECT geom AS input,
ST_ReducePrecision(geom, 10) AS reduced
FROM data;ST_Simplify — Returnerar en förenklad representation av en geometri med hjälp av Douglas-Peucker-algoritmen.
geometry ST_Simplify(geometry geom, float tolerance);
geometry ST_Simplify(geometry geom, float tolerance, boolean preserveCollapsed);
Beräknar en förenklad representation av en geometri med hjälp av Douglas-Peucker-algoritmen. Förenklingstoleransen är ett avståndsvärde, i enheterna för indata SRS. Förenklingen tar bort hörn som ligger inom toleransavståndet för det förenklade linjearbetet. Resultatet kanske inte är giltigt även om indata är det.
Funktionen kan anropas med alla typer av geometri (inklusive GeometryCollections), men endast linje- och polygonelement förenklas. Ändpunkter för linjär geometri bevaras.
Flaggan preserveCollapsed behåller små geometrier som annars skulle tas bort vid den angivna toleransen. Om t.ex. en 1 m lång linje förenklas med en tolerans på 10 m kommer linjen inte att försvinna när preserveCollapsed är true. Denna flagga är användbar för renderingsändamål för att förhindra att mycket små objekt försvinner från en karta.
![]() | |
Den returnerade geometrin kan förlora sin enkelhet (se ST_IsSimple), topologin kanske inte bevaras och polygonala resultat kan vara ogiltiga (se ST_IsValid). Använd ST_SimplifyPreserveTopology för att bevara topologin och säkerställa giltigheten. |
![]() | |
Denna funktion bevarar inte gränser som delas mellan polygoner. Använd ST_CoverageSimplify om detta krävs. |
Tillgänglighet: 1.2.2
A circle simplified with a medium tolerance becomes an octagon, and with a large tolerance disappears.
SELECT ST_NPoints(geom) AS np_before,
ST_NPoints(ST_Simplify(geom, 0.1)) AS np01_notbadcircle,
ST_NPoints(ST_Simplify(geom, 0.5)) AS np05_notquitecircle,
ST_NPoints(ST_Simplify(geom, 1)) AS np1_octagon,
ST_NPoints(ST_Simplify(geom, 10)) AS np10_gone,
(ST_Simplify(geom, 100) is null) AS np100_geometrygoesaway
FROM (SELECT ST_Buffer('POINT(1 3)', 10, 12) As geom) AS t;-[ RECORD 1 ]------------ np_before | 49 np01_notbadcircle | 33 np05_notquitecircle | 17 np1_octagon | 9 np10_gone | null np100_geometrygoesaway | t
Förenkling av en uppsättning linjer. Linjerna kan korsa varandra efter förenklingen.
SELECT ST_Simplify('MULTILINESTRING ((20 180,20 150,50 150,50 100,110 150,150 140,170 120),(20 10,80 30,90 120),(90 120,130 130),(130 130,130 70,160 40,180 60,180 90,140 80),(50 40,70 40,80 70,70 60,60 60,50 50,50 40))'::geometry,
40);MULTILINESTRING((20 180,50 100,170 120),(20 10,90 120),(90 120,130 130),(130 130,160 40,180 90,140 80),(50 40,80 70,50 40))
Förenkla en multipolygon. Polygonala resultat kan vara ogiltiga.
SELECT ST_Simplify('MULTIPOLYGON (((90 110,80 180,50 160,10 170,10 140,20 110,90 110)),((40 80,100 100,120 160,170 180,190 70,140 10,110 40,60 40,40 80),(180 70,170 110,142.5 128.5,128.5 77.5,90 60,180 70)))'::geometry,
40);MULTIPOLYGON(((90 110,80 180,10 170,20 110,90 110)),((40 80,170 180,140 10,40 80),(180 70,142.5 128.5,90 60,180 70)))
ST_IsSimple, ST_SimplifyPreserveTopology, ST_SimplifyVW, ST_CoverageSimplify, Topologi ST_Simplify
ST_SimplifyPreserveTopology — Returnerar en förenklad och giltig representation av en geometri med hjälp av Douglas-Peucker-algoritmen.
geometry ST_SimplifyPreserveTopology(geometry geom, float tolerance);
Beräknar en förenklad representation av en geometri med hjälp av en variant av Douglas-Peucker-algoritmen som begränsar förenklingen för att säkerställa att resultatet har samma topologi som indata. Förenklingstoleransen är ett avståndsvärde, i enheterna för indatans SRS. Förenklingen tar bort toppar som ligger inom toleransavståndet för det förenklade linjeverket, så länge som topologin bevaras. Resultatet kommer att vara giltigt och enkelt om indata är det.
Funktionen kan anropas med alla typer av geometri (inklusive GeometryCollections), men endast linje- och polygonelement förenklas. För polygonala indata kommer resultatet att ha samma antal ringar (skal och hål), och ringarna kommer inte att korsa varandra. Ringarnas ändpunkter kan förenklas. För linjära indata kommer resultatet att ha samma antal linjer, och linjerna kommer inte att korsa varandra om de inte gjorde det i den ursprungliga geometrin. Slutpunkterna för linjär geometri bevaras.
![]() | |
Denna funktion bevarar inte gränser som delas mellan polygoner. Använd ST_CoverageSimplify om detta krävs. |
Utförs av GEOS-modulen.
Tillgänglighet: 1.3.3
For the same example as ST_Simplify, ST_SimplifyPreserveTopology prevents the geometry from disappearing.
SELECT ST_NPoints(geom) AS np_before,
ST_NPoints(ST_SimplifyPreserveTopology(geom, 0.1)) AS np01_notbadcircle,
ST_NPoints(ST_SimplifyPreserveTopology(geom, 0.5)) AS np05_notquitecircle,
ST_NPoints(ST_SimplifyPreserveTopology(geom, 1)) AS np1_octagon,
ST_NPoints(ST_SimplifyPreserveTopology(geom, 10)) AS np10_minimal,
ST_NPoints(ST_SimplifyPreserveTopology(geom, 100)) AS np100_minimal
FROM (SELECT ST_Buffer('POINT(1 3)', 10, 12) AS geom) AS t;np_before | np01_notbadcircle | np05_notquitecircle | np1_octagon | np10_minimal | np100_minimal
-----------+-------------------+---------------------+-------------+--------------+---------------
49 | 33 | 17 | 9 | 4 | 4Förenkla en uppsättning linjer och bevara topologin för icke korsande linjer.
SELECT ST_SimplifyPreserveTopology('MULTILINESTRING ((20 180,20 150,50 150,50 100,110 150,150 140,170 120),(20 10,80 30,90 120),(90 120,130 130),(130 130,130 70,160 40,180 60,180 90,140 80),(50 40,70 40,80 70,70 60,60 60,50 50,50 40))'::geometry,
40);MULTILINESTRING((20 180,50 100,110 150,170 120),(20 10,80 30,90 120),(90 120,130 130),(130 130,130 70,160 40,180 90,140 80),(50 40,70 40,80 70,60 60,50 40))
Förenkling av en multipolygon med bibehållen topologi för skal och hål.
SELECT ST_SimplifyPreserveTopology('MULTIPOLYGON (((90 110,80 180,50 160,10 170,10 140,20 110,90 110)),((40 80,100 100,120 160,170 180,190 70,140 10,110 40,60 40,40 80),(180 70,170 110,142.5 128.5,128.5 77.5,90 60,180 70)))'::geometry,
40);MULTIPOLYGON(((90 110,80 180,10 170,20 110,90 110)),((40 80,100 100,170 180,190 70,140 10,40 80),(180 70,142.5 128.5,90 60,180 70)))
ST_SimplifyPolygonHull — Beräknar ett förenklat topologibevarande yttre eller inre skrov av en polygonal geometri.
geometry ST_SimplifyPolygonHull(geometry param_geom, float vertex_fraction, boolean is_outer = true);
Beräknar ett förenklat topologibevarande yttre eller inre skrov av en polygonal geometri. Ett yttre skrov täcker helt inmatningsgeometrin. Ett inre skrov täcks helt av indatageometrin. Resultatet är en polygonal geometri som bildas av en delmängd av de ingående hörnen. MultiPolygoner och hål hanteras och ger ett resultat med samma struktur som indata.
Minskningen av antalet toppar styrs av parametern vertex_fraction, som är ett tal i intervallet 0 till 1. Lägre värden ger enklare resultat, med mindre antal vertex och mindre konkavitet. För både yttre och inre skrov ger en vertexfraktion på 1,0 den ursprungliga geometrin. För yttre skrov ger ett värde på 0,0 det konvexa skrovet (för en enda polygon); för inre skrov ger det en triangel.
Förenklingsprocessen fungerar genom att gradvis ta bort konkava hörn som innehåller minst yta, tills målet för antalet vertex har uppnåtts. Det förhindrar att kanter korsar varandra, så resultatet är alltid en giltig polygonal geometri.
För att få bättre resultat med geometrier som innehåller relativt långa linjesegment kan det vara nödvändigt att "segmentisera" indata, enligt nedan.
Utförs av GEOS-modulen.
Tillgänglighet: 3.3.0.
Kräver GEOS >= 3.11.0.
Outer hull of a Polygon.
SELECT ST_SimplifyPolygonHull( 'POLYGON ((131 158,136 163,161 165,173 156,179 148,169 140,186 144,190 137,185 131,174 128,174 124,166 119,158 121,158 115,165 107,161 97,166 88,166 79,158 57,145 57,112 53,111 47,93 43,90 48,88 40,80 39,68 32,51 33,40 31,39 34,49 38,34 38,25 34,28 39,36 40,44 46,24 41,17 41,14 46,19 50,33 54,21 55,13 52,11 57,22 60,34 59,41 68,75 72,62 77,56 70,46 72,31 69,46 76,52 82,47 84,56 90,66 90,64 94,56 91,33 97,36 100,23 100,22 107,29 106,31 112,46 116,36 118,28 131,53 132,59 127,62 131,76 130,80 135,89 137,87 143,73 145,80 150,88 150,85 157,99 162,116 158,115 165,123 165,122 170,134 164,131 158))'::geometry, 0.3 );
POLYGON((161 165,173 156,186 144,190 137,185 131,174 124,166 119,166 79,158 57,68 32,40 31,25 34,17 41,14 46,11 57,56 91,33 97,23 100,22 107,28 131,80 135,73 145,85 157,99 162,122 170,161 165))
Inner hull of a Polygon.
SELECT ST_SimplifyPolygonHull( 'POLYGON ((131 158,136 163,161 165,173 156,179 148,169 140,186 144,190 137,185 131,174 128,174 124,166 119,158 121,158 115,165 107,161 97,166 88,166 79,158 57,145 57,112 53,111 47,93 43,90 48,88 40,80 39,68 32,51 33,40 31,39 34,49 38,34 38,25 34,28 39,36 40,44 46,24 41,17 41,14 46,19 50,33 54,21 55,13 52,11 57,22 60,34 59,41 68,75 72,62 77,56 70,46 72,31 69,46 76,52 82,47 84,56 90,66 90,64 94,56 91,33 97,36 100,23 100,22 107,29 106,31 112,46 116,36 118,28 131,53 132,59 127,62 131,76 130,80 135,89 137,87 143,73 145,80 150,88 150,85 157,99 162,116 158,115 165,123 165,122 170,134 164,131 158))'::geometry, 0.3, false );
POLYGON((131 158,116 158,99 162,89 137,76 130,59 127,28 131,46 116,36 100,64 94,75 72,41 68,33 54,68 32,90 48,112 53,145 57,158 57,161 97,158 115,158 121,190 137,169 140,179 148,161 165,131 158))
Outer hull simplification of a MultiPolygon, with segmentization.
WITH letters AS (
SELECT ST_Letters('xt') AS geom
)
SELECT geom AS input,
ST_SimplifyPolygonHull(ST_Segmentize(geom, 2.0), 0.1) AS outer_hull
FROM letters;MULTIPOLYGON(((18.3 57.6,20.7 51,23.3 41.9,26 51,28.4 57.6,45.4 57.6,33.1 28.8,46.6 0,29.5 0,26.6 6.7,23.3 16.3,19.8 6.3,17.1 0,0 0,13.5 28.8,1.3 57.6,18.3 57.6)),((77.808 15.2,82.208 15.2,83.508 16,83.508 -0.9,82.108 -0.2,76.808 -0.2,76.108 -0.2,75.408 -0.2,74.608 -0.1,73.908 -0.1,73.208 0,72.508 0,71.808 0.1,71.108 0.2,70.408 0.3,69.708 0.5,69.008 0.6,68.408 0.9,67.708 1.1,67.008 1.4,66.408 1.7,65.708 2,65.108 2.4,64.408 2.8,63.808 3.2,63.208 3.7,62.608 4.1,62.108 4.7,61.508 5.2,61.008 5.8,60.508 6.4,60.008 7.1,59.508 7.8,59.108 8.6,58.708 9.5,58.308 10.4,57.908 11.3,57.608 12.3,57.608 42.7,52.208 42.7,51.108 41.8,51.108 58.9,52.208 57.9,57.608 57.9,57.608 74.4,56.508 75.4,74.408 75.4,73.308 74.2,73.308 57.9,81.408 57.9,82.508 58.9,82.508 41.8,81.408 42.7,73.308 42.7,73.308 17.7,73.408 17.4,73.608 17.2,73.808 16.9,74.008 16.7,74.208 16.5,74.408 16.3,74.708 16.1,75.008 15.9,75.308 15.7,75.608 15.6,76.008 15.5,76.308 15.4,76.708 15.3,77.008 15.2,77.408 15.2,77.808 15.2))) | MULTIPOLYGON(((45.4 57.6,44.631 55.8,33.869 30.6,46.6 0,29.5 0,19.8 6.3,18.45 3.15,17.1 0,0 0,10.969 23.4,9.688 37.8,2.062 55.8,1.3 57.6,45.4 57.6)),((83.508 16,83.508 -0.9,72.508 0,71.108 0.2,70.408 0.3,69.008 0.6,67.708 1.1,67.008 1.4,65.708 2,64.408 2.8,63.808 3.2,62.608 4.1,61.508 5.2,60.508 6.4,59.508 7.8,59.108 8.6,58.308 10.4,57.908 11.3,57.608 12.3,51.108 41.8,51.108 58.9,56.508 75.4,74.408 75.4,82.508 58.9,83.508 16)))
ST_SimplifyVW — Returnerar en förenklad representation av en geometri med hjälp av Visvalingam-Whyatt-algoritmen
geometry ST_SimplifyVW(geometry geom, float tolerance);
Returns a simplified representation of a geometry using the Visvalingam-Whyatt algorithm. The simplification tolerance is an area value, in squared units of the input SRS. Simplification removes vertices which form "corners" with area less than the tolerance. The result may not be valid even if the input is.
Funktionen kan anropas med alla typer av geometri (inklusive GeometryCollections), men endast linje- och polygonelement förenklas. Ändpunkter för linjär geometri bevaras.
![]() | |
Den returnerade geometrin kan förlora sin enkelhet (se ST_IsSimple), topologin kanske inte bevaras och polygonala resultat kan vara ogiltiga (se ST_IsValid). Använd ST_SimplifyPreserveTopology för att bevara topologin och säkerställa giltigheten. ST_CoverageSimplify bevarar också topologin och giltigheten. |
This is a general-purpose simplification function. It may remove narrow polygon spikes when their effective area is below the tolerance, but it is not a dedicated spike-removal or polygon-repair operation. Use ST_IsValid to check the result and ST_MakeValid to repair invalid polygonal output if needed.
Denna funktion bevarar inte gränser som delas mellan polygoner. Använd ST_CoverageSimplify om detta krävs.
Denna funktion hanterar 3D och den tredje dimensionen kommer att påverka resultatet.
Tillgänglighet: 2.2.0
This polygon has a narrow spike whose effective area is small enough to be removed by a tolerance of 20 square units.
SELECT geom AS original, ST_SimplifyVW(geom, 20) AS simplified FROM (SELECT 'POLYGON((0 0,10 0,10 10,5.2 10,5 16,4.8 10,0 10,0 0))'::geometry AS geom) AS t;
POLYGON((0 0,10 0,10 10,5.2 10,5 16,4.8 10,0 10,0 0)) | POLYGON((0 0,10 0,10 10,0 10,0 0))
A LineString is simplified with a minimum-area tolerance of 30. For a linear simplification using ST_Simplify, a comparable tolerance would be a length in input-SRS units, so the value here is roughly that linear tolerance squared.
SELECT ST_SimplifyVW(geom, 30) simplified FROM (SELECT 'LINESTRING(5 2,3 8,6 20,7 25,10 10)'::geometry AS geom) AS t;
LINESTRING(5 2,7 25,10 10)
Förenkling av en linje.
SELECT ST_SimplifyVW('LINESTRING (10 10,50 40,30 70,50 60,70 80,50 110,100 100,90 140,100 180,150 170,170 140,190 90,180 40,110 40,150 20)'::geometry,
1600);LINESTRING(10 10,100 100,100 180,150 170,190 90,150 20)
Förenkling av en polygon.
SELECT ST_SimplifyVW('POLYGON ((20 20,50 60,20 120,40 170,80 180,120 140,180 180,160 130,180 100,180 30,130 70,150 10,20 20))'::geometry,
1600);POLYGON((20 20,20 120,80 180,160 130,180 30,20 20))
ST_SetEffectiveArea, ST_Simplify, ST_SimplifyPreserveTopology, ST_CoverageSimplify, Topologi ST_Simplify
ST_SetEffectiveArea — Ställer in den effektiva ytan för varje toppunkt med hjälp av Visvalingam-Whyatt-algoritmen.
geometry ST_SetEffectiveArea(geometry geom, float threshold = 0, integer set_area = 1);
Ställer in den effektiva ytan för varje vertex med hjälp av Visvalingam-Whyatt-algoritmen. Den effektiva arean lagras som M-värdet för vertexen. Om den valfria parametern "threshold" används, returneras en förenklad geometri som endast innehåller toppar med en effektiv area som är större än eller lika med tröskelvärdet.
Denna funktion kan användas för förenkling på serversidan när ett tröskelvärde anges. Ett annat alternativ är att använda ett tröskelvärde på noll. I detta fall returneras den fullständiga geometrin med effektiva ytor som M-värden, som kan användas av klienten för att förenkla mycket snabbt.
Kommer faktiskt bara att göra något med (multi)linjer och (multi)polygoner, men du kan säkert anropa den med alla typer av geometri. Eftersom förenklingen sker objekt för objekt kan du också mata in en GeometryCollection till den här funktionen.
![]() | |
Observera att den returnerade geometrin kan förlora sin enkelhet (se ST_IsSimple) |
![]() | |
Observera att topologin kanske inte bevaras och kan resultera i ogiltiga geometrier. Använd (se ST_SimplifyPreserveTopology) för att bevara topologin. |
![]() | |
Utdatageometrin kommer att förlora all tidigare information om M-värdena |
![]() | |
Denna funktion hanterar 3D och den tredje dimensionen kommer att påverka den effektiva ytan |
Tillgänglighet: 2.2.0
Beräkning av den effektiva ytan för en LineString. Eftersom vi använder ett tröskelvärde på noll returneras alla hörn i indatageometrin.
SELECT ST_SetEffectiveArea(geom) AS all_pts,
ST_SetEffectiveArea(geom, 30) AS threshold_30
FROM (SELECT 'LINESTRING(5 2,3 8,6 20,7 25,10 10)'::geometry geom) As foo;ST_TriangulatePolygon — Beräknar den begränsade Delaunay-trianguleringen av polygoner
geometry ST_TriangulatePolygon(geometry geom);
Beräknar den begränsade Delaunay-trianguleringen av polygoner. Stöd finns för hål och multipolygoner.
Den "begränsade Delaunay-trianguleringen" av en polygon är en uppsättning trianglar som bildas från polygonens hörn och täcker den exakt, med den maximala totala inre vinkeln över alla möjliga trianguleringar. Den ger den "bästa kvaliteten" på trianguleringen av polygonen.
Tillgänglighet: 3.3.0.
Kräver GEOS >= 3.11.0.
Triangulering av en kvadrat.
SELECT ST_TriangulatePolygon('POLYGON((0 0,0 1,1 1,1 0,0 0))');GEOMETRYCOLLECTION(POLYGON((0 0,0 1,1 1,0 0)), POLYGON((1 1,1 0,0 0,1 1)))
Triangulering av bokstaven P.
SELECT ST_TriangulatePolygon('POLYGON ((26 17,31 19,34 21,37 24,38 29,39 43,39 161,38 172,36 176,34 179,30 181,25 183,10 185,10 190,100 190,121 189,139 187,154 182,167 177,177 169,184 161,189 152,190 141,188 128,186 123,184 117,180 113,176 108,170 104,164 101,151 96,136 92,119 89,100 89,86 89,73 89,73 39,74 32,75 27,77 23,79 20,83 18,89 17,106 15,106 10,10 10,10 15,26 17),(152 147,151 152,149 157,146 162,142 166,137 169,132 172,126 175,118 177,109 179,99 180,89 180,80 179,76 178,74 176,73 171,73 100,85 99,91 99,102 99,112 100,121 102,128 104,134 107,139 110,143 114,147 118,149 123,151 128,153 141,152 147))'
);GEOMETRYCOLLECTION (POLYGON ((10 10, 10 15, 26 17, 10 10)), POLYGON ((25 183, 10 185, 10 190, 25 183)), POLYGON ((126 175, 121 189, 139 187, 126 175)), POLYGON ((137 169, 139 187, 154 182, 137 169)), POLYGON ((149 157, 167 177, 177 169, 149 157)), POLYGON ((153 141, 189 152, 190 141, 153 141)), POLYGON ((153 141, 188 128, 186 123, 153 141)), POLYGON ((186 123, 184 117, 180 113, 186 123)), POLYGON ((149 123, 176 108, 170 104, 149 123)), POLYGON ((147 118, 164 101, 151 96, 147 118)), POLYGON ((121 102, 136 92, 119 89, 121 102)), POLYGON ((85 99, 73 89, 73 100, 85 99)), POLYGON ((89 17, 106 15, 106 10, 89 17)), POLYGON ((83 18, 10 10, 26 17, 83 18)), POLYGON ((100 190, 25 183, 10 190, 100 190)), POLYGON ((121 189, 109 179, 100 190, 121 189)), POLYGON ((189 152, 152 147, 184 161, 189 152)), POLYGON ((153 141, 190 141, 188 128, 153 141)), POLYGON ((147 118, 170 104, 164 101, 147 118)), POLYGON ((139 110, 151 96, 136 92, 139 110)), POLYGON ((73 89, 85 99, 86 89, 73 89)), POLYGON ((83 18, 89 17, 106 10, 83 18)), POLYGON ((83 18, 26 17, 31 19, 83 18)), POLYGON ((100 190, 30 181, 25 183, 100 190)), POLYGON ((189 152, 153 141, 152 147, 189 152)), POLYGON ((176 108, 151 128, 180 113, 176 108)), POLYGON ((91 99, 86 89, 85 99, 91 99)), POLYGON ((10 10, 83 18, 106 10, 10 10)), POLYGON ((76 178, 100 190, 80 179, 76 178)), POLYGON ((86 89, 91 99, 100 89, 86 89)), POLYGON ((79 20, 83 18, 31 19, 79 20)), POLYGON ((102 99, 100 89, 91 99, 102 99)), POLYGON ((34 21, 79 20, 31 19, 34 21)), POLYGON ((112 100, 100 89, 102 99, 112 100)), POLYGON ((37 24, 79 20, 34 21, 37 24)), POLYGON ((100 89, 112 100, 119 89, 100 89)), POLYGON ((79 20, 37 24, 77 23, 79 20)), POLYGON ((119 89, 112 100, 121 102, 119 89)), POLYGON ((77 23, 37 24, 75 27, 77 23)), POLYGON ((136 92, 121 102, 128 104, 136 92)), POLYGON ((38 29, 75 27, 37 24, 38 29)), POLYGON ((134 107, 136 92, 128 104, 134 107)), POLYGON ((75 27, 38 29, 74 32, 75 27)), POLYGON ((139 110, 136 92, 134 107, 139 110)), POLYGON ((74 32, 38 29, 73 39, 74 32)), POLYGON ((151 96, 139 110, 143 114, 151 96)), POLYGON ((39 43, 73 39, 38 29, 39 43)), POLYGON ((151 96, 143 114, 147 118, 151 96)), POLYGON ((73 39, 39 43, 73 89, 73 39)), POLYGON ((170 104, 147 118, 149 123, 170 104)), POLYGON ((73 89, 39 43, 73 100, 73 89)), POLYGON ((176 108, 149 123, 151 128, 176 108)), POLYGON ((39 161, 73 100, 39 43, 39 161)), POLYGON ((180 113, 151 128, 186 123, 180 113)), POLYGON ((73 100, 39 161, 73 171, 73 100)), POLYGON ((186 123, 151 128, 153 141, 186 123)), POLYGON ((38 172, 73 171, 39 161, 38 172)), POLYGON ((151 152, 184 161, 152 147, 151 152)), POLYGON ((73 171, 38 172, 74 176, 73 171)), POLYGON ((184 161, 151 152, 177 169, 184 161)), POLYGON ((36 176, 74 176, 38 172, 36 176)), POLYGON ((149 157, 177 169, 151 152, 149 157)), POLYGON ((34 179, 74 176, 36 176, 34 179)), POLYGON ((146 162, 167 177, 149 157, 146 162)), POLYGON ((74 176, 34 179, 76 178, 74 176)), POLYGON ((167 177, 146 162, 154 182, 167 177)), POLYGON ((30 181, 76 178, 34 179, 30 181)), POLYGON ((154 182, 146 162, 142 166, 154 182)), POLYGON ((100 190, 76 178, 30 181, 100 190)), POLYGON ((154 182, 142 166, 137 169, 154 182)), POLYGON ((80 179, 100 190, 89 180, 80 179)), POLYGON ((139 187, 137 169, 132 172, 139 187)), POLYGON ((100 190, 99 180, 89 180, 100 190)), POLYGON ((139 187, 132 172, 126 175, 139 187)), POLYGON ((100 190, 109 179, 99 180, 100 190)), POLYGON ((121 189, 126 175, 118 177, 121 189)), POLYGON ((121 189, 118 177, 109 179, 121 189)))
Triangulation of the polygon used in the CG_Tesselate example.
SELECT ST_TriangulatePolygon('POLYGON (( 10 190,10 70,80 70,80 130,50 160,120 160,120 190,10 190 ))'::geometry
);GEOMETRYCOLLECTION(POLYGON((50 160,120 190,120 160,50 160)), POLYGON((10 70,80 130,80 70,10 70)), POLYGON((50 160,10 70,10 190,50 160)), POLYGON((120 190,50 160,10 190,120 190)), POLYGON((80 130,10 70,50 160,80 130)))
ST_VoronoiLines — Returnerar gränserna för Voronoi-diagrammet för geometrins hörnpunkter.
geometry ST_VoronoiLines( geometry geom , float8 tolerance = 0.0 , geometry extend_to = NULL );
Beräknar ett tvådimensionellt Voronoi-diagram från hörnen i den angivna geometrin och returnerar gränserna mellan cellerna i diagrammet som en MultiLineString. Returnerar null om indatageometrin är null. Returnerar en tom geometrisamling om indatageometrin endast innehåller ett vertex. Returnerar en tom geometrisamling om extend_to-kuvertet har noll area.
Valfria parametrar:
tolerans: Det avstånd inom vilket hörn anses vara likvärdiga. Algoritmens robusthet kan förbättras genom att ange ett toleransavstånd som inte är noll. (standard = 0,0)
extend_to: Om detta anges utökas diagrammet så att det täcker den medföljande geometrins omslutningsyta, om den inte är mindre än standardomslutningsytan (standard = NULL, standardomslutningsytan är inmatningsytans begränsningsbox utökad med ca 50%).
Utförs av GEOS-modulen.
Tillgänglighet: 2.3.0
Voronoi diagram lines with a tolerance of 30 units.
SELECT ST_VoronoiLines('MULTIPOINT (50 30,60 30,100 100,10 150,110 120)'::geometry,
30) AS geom;
MULTILINESTRING((135.555555555556 270,36.8181818181818 92.2727272727273),(36.8181818181818 92.2727272727273,-110 43.3333333333333),(230 -45.7142857142858,36.8181818181818 92.2727272727273))
ST_VoronoiPolygons — Returnerar cellerna i Voronoi-diagrammet för hörnen i en geometri.
geometry ST_VoronoiPolygons( geometry geom , float8 tolerance = 0.0 , geometry extend_to = NULL );
Beräknar ett tvådimensionellt Voronoi-diagram från hörnen i den angivna geometrin. Resultatet är en GEOMETRYCOLLECTION av POLYGONER som täcker ett kuvert som är större än omfattningen av de ingående hörnen. Returnerar null om indatageometrin är null. Returnerar en tom geometrisamling om indatageometrin endast innehåller en vertex. Returnerar en tom geometrisamling om extend_to-kuvertet har noll area.
Valfria parametrar:
tolerans: Det avstånd inom vilket hörn anses vara likvärdiga. Algoritmens robusthet kan förbättras genom att ange ett toleransavstånd som inte är noll. (standard = 0,0)
extend_to: Om detta anges utökas diagrammet så att det täcker den medföljande geometrins omslutningsyta, om den inte är mindre än standardomslutningsytan (standard = NULL, standardomslutningsytan är inmatningsytans begränsningsbox utökad med ca 50%).
Utförs av GEOS-modulen.
Tillgänglighet: 2.3.0
Points overlaid on top of the Voronoi diagram.
SELECT ST_VoronoiPolygons('MULTIPOINT (50 30,60 30,100 100,10 150,110 120)'::geometry
) AS geom;
GEOMETRYCOLLECTION(POLYGON((-110 270,100.5 270,59.34782608695652 132.82608695652175,36.81818181818182 92.27272727272727,-110 43.33333333333332,-110 270)), POLYGON((-110 -90,-110 43.33333333333332,36.81818181818182 92.27272727272727,55 79.28571428571429,55 -90,-110 -90)), POLYGON((230 -20.71428571428572,55 79.28571428571429,36.81818181818182 92.27272727272727,59.34782608695652 132.82608695652175,230 47.50000000000001,230 -20.71428571428572)), POLYGON((230 -90,55 -90,55 79.28571428571429,230 -20.71428571428572,230 -90)), POLYGON((230 270,230 47.50000000000001,59.34782608695652 132.82608695652175,100.5 270,230 270)))
Voronoi diagram with a tolerance of 30 units.
SELECT ST_VoronoiPolygons('MULTIPOINT (50 30,60 30,100 100,10 150,110 120)'::geometry,
30) AS geom;
GEOMETRYCOLLECTION(POLYGON((-110 270,135.55555555555557 270,36.81818181818182 92.27272727272727,-110 43.33333333333332,-110 270)), POLYGON((230 270,230 -45.71428571428574,36.81818181818182 92.27272727272727,135.55555555555557 270,230 270)), POLYGON((230 -90,-110 -90,-110 43.33333333333332,36.81818181818182 92.27272727272727,230 -45.71428571428574,230 -90)))
Dessa funktioner arbetar med uppsättningar av polygonal geometri som bildar "implicita täckningar". För att bilda en giltig täckning får polygonerna inte överlappa varandra och hörnen på intilliggande kanter måste matcha varandra exakt. Täckningar är snabba att bearbeta och kan hanteras med fönsterfunktioner, som behåller täckningens topologi inuti fönsterpartitionen samtidigt som kanterna ändras.
ST_CoverageInvalidEdges — Fönsterfunktion som hittar platser där polygonerna inte bildar en giltig täckning.
geometry ST_CoverageInvalidEdges(geometry winset geom, float8 tolerance = 0);
En fönsterfunktion som kontrollerar om polygonerna i fönsterpartitionen bildar en giltig polygontäckning. Den returnerar linjära indikatorer som visar var ogiltiga kanter (om sådana finns) finns i varje polygon.
En uppsättning giltiga polygoner är en giltig täckning om följande villkor uppfylls:
Icke-överlappande - polygoner överlappar inte varandra (deras inre delar skär inte varandra)
Edge-Matched - toppar längs delade kanter är identiska
Som en fönsterfunktion returneras ett värde för varje polygon som matas in. För polygoner som bryter mot ett eller flera av giltighetsvillkoren är returvärdet en MULTILINESTRING som innehåller de problematiska kanterna. Täckningsgilla polygoner returnerar värdet NULL. Icke-polygonala eller tomma geometrier producerar också NULL-värden.
Villkoren tillåter att en giltig täckning innehåller hål (mellanrum mellan polygoner), så länge som de omgivande polygonerna är kantmatchade. Mycket smala luckor är dock ofta inte önskvärda. Om toleransparametern anges med ett avstånd som inte är noll, kommer kanter som bildar smalare luckor också att returneras som ogiltiga.
De polygoner som kontrolleras för täckningsgiltighet måste också vara giltiga geometrier. Detta kan kontrolleras med ST_IsValid.
Tillgänglighet: 3.4.0
Kräver GEOS >= 3.12.0
Invalid edges caused by overlap and non-matching vertices.
WITH coverage(id, geom) AS (VALUES (1, 'POLYGON ((10 190,30 160,40 110,100 70,120 10,10 10,10 190))'::geometry), (2, 'POLYGON ((100 190,10 190,30 160,40 110,50 80,74 110.5,100 130,140 120,140 160,100 190))'::geometry), (3, 'POLYGON ((140 190,190 190,190 80,140 80,140 190))'::geometry), (4, 'POLYGON ((180 40,120 10,100 70,140 80,190 80,180 40))'::geometry) ) SELECT id, ST_CoverageInvalidEdges(geom) OVER () FROM coverage;
id | st_astext ----+--------------------------------------- 1 | LINESTRING (40 110, 100 70) 2 | MULTILINESTRING ((100 130, 140 120, 140 160, 100 190), (40 110, 50 80, 74 110.5)) 3 | LINESTRING (140 80, 140 190) 4 | null
This example tests the entire table for coverage validity.
SELECT true = ALL (
SELECT ST_CoverageInvalidEdges(geom) OVER () IS NULL
FROM coverage
);
ST_CoverageClean — Beräknar en ren (kantmatchad, icke-överlappande, gap-cleared) polygontäckning, givet en icke ren indata.
geometry ST_CoverageClean(geometry winset geom, float8 gapMaximumWidth = 0, float8 snappingDistance = -1, text overlapMergeStrategy = 'MERGE_LONGEST_BORDER');
A window function which adjusts the edges of a set of valid polygonal geometries to produce a clean coverage. Cleaning involves:
snapping vertices and edges to remove small discrepancies and ensure common edges are identically noded
merging overlaps into a parent polygon
merging narrow gaps into adjacent polygons
gapMaximumWidth controls which gaps between polygons are merged. Gaps with width <= this distance are merged into an adjacent polygon.
snappingDistance controls snapping of vertices and edges. The default (-1) automatically determines a snapping distance based on the input extent. Set to 0.0 to turn off snapping.
overlapMergeStrategy specifies how overlaps are merged into a parent polygon:
MERGE_LONGEST_BORDER - merges into polygon with longest common border
MERGE_MAX_AREA - merges into polygon with maximum area
MERGE_MIN_AREA - merges into polygon with minimum area
MERGE_MIN_INDEX - merges into polygon with smallest input index (defined by order of input polygons)
The result is a clean polygonal coverage that will pass validation by ST_CoverageInvalidEdges and can be input to coverage processing functions.
![]() | |
To aid in determining a maximum gap width, gaps can be computed by cleaning with |
Tillgänglighet: 3.6.0 - kräver GEOS >= 3.14.0
Clean a coverage containing overlaps and narrow gaps, and compare the cleaned polygons with the original invalid edges.
WITH coverage(id, geom) AS (VALUES
(1, 'POLYGON ((10 190,30 160,27 134.5,40 110,122 47,120 10,10 10,10 190))'::geometry),
(2, 'POLYGON ((150 190,10 190,30 160,50 140,40 110,50 80,130 70,135 111,140 130,140 160,150 190))'::geometry),
(3, 'POLYGON ((140 190,190 190,190 80,140 80,140 190))'::geometry),
(4, 'POLYGON ((190 10,120 10,97 77,160 90,170 70,190 80,190 10))'::geometry)
), processed AS (
SELECT id,
ST_CoverageClean(geom, 1) OVER () AS cleaned,
ST_CoverageInvalidEdges(geom) OVER () AS invalid_edges
FROM coverage
)
SELECT ST_Collect(cleaned ORDER BY id) AS cleaned,
ST_Collect(invalid_edges ORDER BY id) AS invalid_edges
FROM processed;MULTIPOLYGON(((10 10,10 190,30 160,27 134.5,40 110,84.7 75.7,102 62.3,120 10,10 10)),((140 190,140 160,140 130,135 111,131.7 84.2,97 77,98 74,84.7 75.7,40 110,50 140,30 160,10 190,140 190)),((190 190,190 80,165 80,140 80,140 85.9,140 130,140 160,140 190,150 190,190 190)),((190 10,120 10,102 62.3,98 74,97 77,131.7 84.2,140 85.9,140 80,165 80,170 70,190 80,190 10))) | MULTILINESTRING((40 110,122 47,120 10),(40 110,50 80,130 70,135 111,140 130,140 160,150 190,10 190),(190 80,140 80,140 190,190 190),(120 10,97 77,160 90,170 70))
ST_CoverageSimplify — Fönsterfunktion som förenklar kanterna på en polygonal täckning.
geometry ST_CoverageSimplify(geometry winset geom, float8 tolerance, boolean simplifyBoundary = true);
En fönsterfunktion som förenklar kanterna på polygoner i en polygonal täckning. Förenklingen bevarar täckningens topologi. Detta innebär att de förenklade polygonerna är konsekventa längs delade kanter och fortfarande utgör en giltig täckning.
Vid förenklingen används en variant av Visvalingam-Whyatt-algoritmen. Toleransparametern har avståndsenheter och är ungefär lika med kvadratroten av de triangulära områden som ska förenklas.
Om du bara vill förenkla täckningens "inre" kanter (de som delas av två polygoner) ska du ange parametern simplifyBoundary till false.
Use this function to simplify adjacent polygon layers when shared boundaries must remain edge-matched. For a single geometry where only self-intersection and ring validity matter, see ST_SimplifyPreserveTopology.
![]() | |
Om indata inte är en giltig täckning kan det förekomma oväntade artefakter i utdata (t.ex. gränssnitt eller separerade gränser som verkade vara delade). Använd ST_CoverageInvalidEdges för att avgöra om en täckning är giltig. |
Tillgänglighet: 3.4.0
Kräver GEOS >= 3.12.0
Simplify a polygonal coverage while preserving shared boundaries.
WITH coverage(id, geom) AS (VALUES (1, 'POLYGON ((160 150,110 130,90 100,90 70,60 60,50 10,30 30,40 50,25 40,10 60,30 100,30 120,20 170,60 180,90 190,130 180,130 160,160 150),(40 160,50 140,66 125,60 100,80 140,90 170,60 160,40 160))'::geometry), (2, 'POLYGON ((40 160,60 160,90 170,80 140,60 100,66 125,50 140,40 160))'::geometry), (3, 'POLYGON ((110 130,160 50,140 50,120 33,90 30,50 10,60 60,90 70,90 100,110 130))'::geometry), (4, 'POLYGON ((160 150,150 120,160 90,160 50,110 130,160 150))'::geometry) ) SELECT id, ST_CoverageSimplify(geom, 30) OVER () FROM coverage;
id | st_astext ----+--------------------------------------- 1 | POLYGON ((160 150, 110 130, 50 10, 10 60, 20 170, 90 190, 160 150), (40 160, 66 125, 90 170, 40 160)) 2 | POLYGON ((40 160, 66 125, 90 170, 40 160)) 3 | POLYGON ((110 130, 160 50, 50 10, 110 130)) 4 | POLYGON ((160 150, 160 50, 110 130, 160 150))
ST_CoverageEdges — Computes the unique edges of a polygonal coverage.
geometry ST_CoverageEdges(geometry geom, integer edgetype = 0);
geometry ST_CoverageEdges(geometry[] geoms, integer edgetype = 0);
Returns a MultiLineString representing the unique edges of a polygonal coverage. A polygonal coverage is a set of non-overlapping polygons where adjacent polygons have matching vertices along shared edges.
The edgetype parameter can be used to select which edges are returned:
0 (ALL) - all unique edges (default)
1 (EXTERIOR) - only exterior edges (non-shared)
2 (INTERIOR) - only interior edges (shared)
Availability: 3.7.0
Requires GEOS >= 3.15.0
This example returns all unique edges of a coverage.
WITH coverage(geom) AS (
VALUES (
'GEOMETRYCOLLECTION(
POLYGON((0 0,10 0,10 10,0 10,0 0)),
POLYGON((10 0,20 0,20 10,10 10,10 0))
)'::geometry
)
)
SELECT geom AS input_coverage,
ST_CoverageEdges(geom) AS all_edges
FROM coverage;This example returns only the interior shared edges of a coverage.
WITH coverage(geom) AS (
VALUES (
'GEOMETRYCOLLECTION(
POLYGON((0 0,10 0,10 10,0 10,0 0)),
POLYGON((10 0,20 0,20 10,10 10,10 0))
)'::geometry
)
)
SELECT geom AS input_coverage,
ST_CoverageEdges(geom, 2) AS shared_edges
FROM coverage;ST_CoverageUnion — Beräknar unionen av en uppsättning polygoner som bildar en täckning genom att ta bort gemensamma kanter.
geometry ST_CoverageUnion(geometry set geom);
En aggregatfunktion som förenar en uppsättning polygoner som bildar en polygontäckning. Resultatet är en polygonal geometri som täcker samma område som täckningen. Denna funktion ger samma resultat som ST_Union, men använder täckningsstrukturen för att beräkna sammanslagningen mycket snabbare.
![]() | |
Om indata inte är en giltig täckning kan det uppstå oväntade artefakter i utdata (t.ex. polygoner som inte är sammansmälta eller överlappar varandra). Använd ST_CoverageInvalidEdges för att avgöra om en täckning är giltig. |
Tillgänglighet: 3.4.0 - kräver GEOS >= 3.8.0
Union a polygonal coverage.
WITH coverage(id, geom) AS (VALUES (1, 'POLYGON ((10 10,10 150,80 190,110 150,90 110,40 110,50 60,10 10))'::geometry), (2, 'POLYGON ((120 10,10 10,50 60,100 70,120 10))'::geometry), (3, 'POLYGON ((140 80,120 10,100 70,40 110,90 110,110 150,140 80))'::geometry), (4, 'POLYGON ((140 190,120 170,140 130,160 150,140 190))'::geometry), (5, 'POLYGON ((180 160,170 140,140 130,160 150,140 190,180 160))'::geometry) ) SELECT ST_CoverageUnion(geom) AS wkt FROM coverage;
MULTIPOLYGON(((10 150,80 190,110 150,140 80,120 10,10 10,10 150),(50 60,100 70,40 110,50 60)),((120 170,140 190,180 160,170 140,140 130,120 170)))
Dessa funktioner ändrar geometrins position och form med hjälp av affina transformationer.
ST_Affine — Tillämpa en 3D-affin transformation på en geometri.
geometry ST_Affine(geometry geomA, float a, float b, float c, float d, float e, float f, float g, float h, float i, float xoff, float yoff, float zoff);
geometry ST_Affine(geometry geomA, float a, float b, float d, float e, float xoff, float yoff);
Tillämpar en 3D-affin transformation på geometrin för att göra saker som att translatera, rotera och skala i ett steg.
Version 1: Anropet
ST_Affine(geom, a, b, c, d, e, f, g, h, i, xoff, yoff, zoff
) representerar transformationsmatrisen
/ a b c xoff \ | d e f yoff | | g h i zoff | g h i zoff | \ 0 0 0 1 /
och topparna transformeras på följande sätt:
x' = a*x + b*y + c*z + xoff y' = d*x + e*y + f*z + yoff z' = g*x + h*y + i*z + zoff
Alla översättnings- / skalningsfunktioner nedan uttrycks via en sådan affin transformation.
Version 2: Tillämpar en 2D-affin transformation på geometrin. Anropet
ST_Affine(geom, a, b, d, e, xoff, yoff)
representerar transformationsmatrisen
/ a b 0 xoff \ / a b xoff \ | d e 0 yoff | rsp. | d e yoff | | d e yoff | 0 0 1 0 | \ 0 0 1 / \ 0 0 0 1 /
och topparna transformeras på följande sätt:
x' = a*x + b*y + xoff y' = d*x + e*y + yoff z' = z
Denna metod är ett delfall av 3D-metoden ovan.
Förbättrad: 2.0.0 stöd för polyhedrala ytor, trianglar och TIN infördes.
Tillgänglighet: 1.1.2. Namn ändrat från Affine till ST_Affine i 1.2.2
![]() | |
Före 1.3.4 kraschade den här funktionen om den användes med geometrier som innehåller CURVES. Detta är åtgärdat i 1.3.4+ |
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
Rotate a 3D line 180 degrees about the z axis. Note this is long-hand for doing ST_Rotate();
SELECT ST_Affine(geom, cos(pi()), -sin(pi()), 0, sin(pi()), cos(pi()), 0, 0, 0, 1, 0, 0, 0) As using_affine,
ST_Rotate(geom, pi()) As using_rotate
FROM (SELECT 'LINESTRING(1 2 3,1 4 3)'::geometry As geom) As foo;using_affine | using_rotate -----------------------------+----------------------------- LINESTRING(-1 -2 3,-1 -4 3) | LINESTRING(-1 -2 3,-1 -4 3) (1 row)
Rotate a 3D line 180 degrees in both the x and z axis.
SELECT ST_Affine(geom, cos(pi()), -sin(pi()), 0, sin(pi()), cos(pi()), -sin(pi()), 0, sin(pi()), cos(pi()), 0, 0, 0)
FROM (SELECT 'LINESTRING(1 2 3,1 4 3)'::geometry As geom) As foo;LINESTRING(-1 -2 -3,-1 -4 -3)
ST_Rotate — Roterar en geometri runt en ursprungspunkt.
geometry ST_Rotate(geometry geomA, float rotRadians);
geometry ST_Rotate(geometry geomA, float rotRadians, float x0, float y0);
geometry ST_Rotate(geometry geomA, float rotRadians, geometry pointOrigin);
Roterar geometrin rotRadians moturs runt ursprungspunkten. Rotationsursprunget kan anges antingen som en POINT-geometri eller som x- och y-koordinater. Om origo inte anges roteras geometrin kring POINT(0 0).
Förbättrad: 2.0.0 stöd för polyhedrala ytor, trianglar och TIN infördes.
Förbättrad: 2.0.0 ytterligare parametrar för att ange rotationens ursprung lades till.
Tillgänglighet: 1.1.2. Namn ändrat från Rotate till ST_Rotate i 1.2.2
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
This example rotates a geometry by 180 degrees.
SELECT ST_Rotate('LINESTRING (50 160,50 50,100 50)'::geometry, pi());LINESTRING(-50 -160,-50 -50,-100 -50)
This example rotates a geometry 30 degrees counter-clockwise around x=50, y=160.
SELECT ST_Rotate('LINESTRING (50 160,50 50,100 50)'::geometry, pi()/6, 50, 160);LINESTRING(50 160,105 64.737206,148.30127 89.737206)
This example rotates a geometry 60 degrees clockwise around its centroid.
SELECT ST_Rotate(geom, -pi()/3, ST_Centroid(geom)) FROM (SELECT 'LINESTRING (50 160,50 50,100 50)'::geometry AS geom) AS foo;
LINESTRING(116.4225 130.6721,21.1597 75.6721,46.1597 32.3708)
ST_RotateX — Roterar en geometri runt X-axeln.
geometry ST_RotateX(geometry geomA, float rotRadians);
Roterar en geometri geomA - rotRadians runt X-axeln.
![]() | |
|
Förbättrad: 2.0.0 stöd för polyhedrala ytor, trianglar och TIN infördes.
Tillgänglighet: 1.1.2. Namn ändrat från RotateX till ST_RotateX i 1.2.2
Denna funktion stöder polyedriska ytor.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
This example rotates a line 90 degrees around the X axis.
SELECT ST_RotateX('LINESTRING(1 2 3,1 1 1)', pi()/2);LINESTRING(1 -3 2,1 -1 1)
ST_RotateY — Roterar en geometri runt Y-axeln.
geometry ST_RotateY(geometry geomA, float rotRadians);
Roterar en geometri geomA - rotRadians runt y-axeln.
![]() | |
|
Tillgänglighet: 1.1.2. Namn ändrat från RotateY till ST_RotateY i 1.2.2
Förbättrad: 2.0.0 stöd för polyhedrala ytor, trianglar och TIN infördes.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
This example rotates a line 90 degrees around the Y axis.
SELECT ST_RotateY('LINESTRING(1 2 3,1 1 1)', pi()/2);LINESTRING(3 2 -1,1 1 -1)
ST_RotateZ — Roterar en geometri runt Z-axeln.
geometry ST_RotateZ(geometry geomA, float rotRadians);
Roterar en geometri geomA - rotRadians runt Z-axeln.
![]() | |
Detta är en synonym för ST_Rotate |
![]() | |
|
Förbättrad: 2.0.0 stöd för polyhedrala ytor, trianglar och TIN infördes.
Tillgänglighet: 1.1.2. Namn ändrat från RotateZ till ST_RotateZ i 1.2.2
![]() | |
Före 1.3.4 kraschade den här funktionen om den användes med geometrier som innehåller CURVES. Detta är åtgärdat i 1.3.4+ |
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
This example rotates a line 90 degrees around the Z axis.
SELECT ST_RotateZ('LINESTRING(1 2 3,1 1 1)', pi()/2);LINESTRING(-2 1 3,-1 1 1)
This example rotates a curved circle around the Z axis.
SELECT ST_RotateZ(geom, pi()/2)
FROM (SELECT ST_LineToCurve(ST_Buffer('POINT(234 567)'::geometry, 3)) As geom) As foo;CURVEPOLYGON(CIRCULARSTRING(-567 237.00000000000003,-567 231.00000000000003,-567 237.00000000000003))
ST_Scale — Skalar en geometri med givna faktorer.
geometry ST_Scale(geometry geomA, float XFactor, float YFactor, float ZFactor);
geometry ST_Scale(geometry geomA, float XFactor, float YFactor);
geometry ST_Scale(geometry geom, geometry factor);
geometry ST_Scale(geometry geom, geometry factor, geometry origin);
Skalar geometrin till en ny storlek genom att multiplicera ordinaterna med motsvarande faktorparametrar.
Den version som tar en geometri som faktorparameter gör det möjligt att skicka en 2d-, 3dm-, 3dz- eller 4d-punkt för att ställa in skalningsfaktorn för alla dimensioner som stöds. Saknade dimensioner i faktorpunkten motsvarar ingen skalning av motsvarande dimension.
Varianten med tre geometrier gör det möjligt att ange ett "falskt ursprung" för skalningen. Detta möjliggör "skalning på plats", t.ex. genom att geometrins centroid används som falskt ursprung. Utan ett falskt ursprung sker skalningen i förhållande till det faktiska ursprunget, så alla koordinater multipliceras bara med skalfaktorn.
![]() | |
Före 1.3.4 kraschade den här funktionen om den användes med geometrier som innehåller CURVES. Detta är åtgärdat i 1.3.4+ |
Tillgänglighet: 1.1.0.
Förbättrad: 2.0.0 stöd för polyhedrala ytor, trianglar och TIN infördes.
Förbättrad: 2.2.0 stöd för skalning av alla dimensioner(faktorparameter) infördes.
Förbättrad: 2.5.0 stöd för skalning i förhållande till ett lokalt ursprung (origin-parametern) infördes.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
Denna funktion stöder M-koordinater.
This example scales X, Y, and Z values.
SELECT ST_Scale('LINESTRING(1 2 3,1 1 1)', 0.5, 0.75, 0.8);LINESTRING(0.5 1.5 2.4,0.5 0.75 0.8)
This example scales X and Y values.
SELECT ST_Scale('LINESTRING(1 2 3,1 1 1)', 0.5, 0.75);LINESTRING(0.5 1.5 3,0.5 0.75 1)
This example scales X, Y, Z, and M values.
SELECT ST_Scale('LINESTRING(1 2 3 4,1 1 1 1)',
ST_MakePoint(0.5, 0.75, 2, -1));LINESTRING(0.5 1.5 6 -4,0.5 0.75 2 -1)
This example scales X and Y values using a false origin.
SELECT ST_Scale('LINESTRING(1 1,2 2)', 'POINT(2 2)', 'POINT(1 1)'::geometry);LINESTRING(1 1,3 3)
ST_Translate — Translaterar en geometri med givna offsets.
geometry ST_Translate(geometry g1, float deltax, float deltay);
geometry ST_Translate(geometry g1, float deltax, float deltay, float deltaz);
Returns a new geometry whose coordinates are translated delta x,delta y,delta z units. Units are based on the units defined in spatial reference (SRID) for this geometry. M coordinates are preserved.
![]() | |
Före 1.3.4 kraschade den här funktionen om den användes med geometrier som innehåller CURVES. Detta är åtgärdat i 1.3.4+ |
Tillgänglighet: 1.2.2
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder M-koordinater.
Flytta en punkt 1 grads longitud
SELECT ST_Translate(ST_GeomFromText('POINT(-71.01 42.37)', 4326), 1, 0) AS wgs_transgeomtxt;POINT(-70.01 42.37)
Flytta en linestrings 1 grads longitud och 1/2 grads latitud
SELECT ST_Translate(ST_GeomFromText('LINESTRING(-71.01 42.37,-71.11 42.38)', 4326), 1, 0.5) AS wgs_transgeomtxt;LINESTRING(-70.01 42.87,-70.11 42.88)
Flytta en 3d-punkt
SELECT ST_Translate(CAST('POINT(0 0 0)' AS geometry), 5, 12, 3);POINT(5 12 3)
Move points with a measure coordinate
SELECT ST_Translate('POINTM(0 0 11)', 5, 12);POINTM(5 12 11)
SELECT ST_Translate('POINT(0 0 7 11)', 5, 12, 3);POINT(5 12 10 11)
Flytta en kurva och en punkt
SELECT ST_Translate(ST_Collect('CURVEPOLYGON(CIRCULARSTRING(4 3,3.12 0.878,1 0,-1.121 5.1213,6 7,8 9,4 3))', 'POINT(1 3)'), 1, 2);GEOMETRYCOLLECTION(CURVEPOLYGON(CIRCULARSTRING(5 5,4.12 2.878,2 2,-0.121 7.1213,7 9,9 11,5 5)), POINT(2 5))
ST_TransScale — Translaterar och skalar en geometri med hjälp av givna offsets och faktorer.
geometry ST_TransScale(geometry geomA, float deltaX, float deltaY, float XFactor, float YFactor);
Translaterar geometrin med hjälp av argen deltaX och deltaY och skalar den sedan med hjälp av argen XFactor och YFactor, endast i 2D.
![]() | |
|
![]() | |
Före 1.3.4 kraschade den här funktionen om den användes med geometrier som innehåller CURVES. Detta är åtgärdat i 1.3.4+ |
Tillgänglighet: 1.1.0.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
SELECT ST_TransScale('LINESTRING(1 2 3,1 1 1)', 0.5, 1, 1, 2);LINESTRING(1.5 6 3,1.5 4 1)
This example buffers a point to approximate a circle, converts it to a curve, translates it by 1,2, and scales it by 3,4.
SELECT ST_TransScale(ST_LineToCurve(ST_Buffer('POINT(234 567)', 3)), 1, 2, 3, 4);CURVEPOLYGON(CIRCULARSTRING(714 2276,696 2276,714 2276))
Dessa funktioner implementerar klusteralgoritmer för uppsättningar av geometrier.
ST_ClusterDBSCAN — Fönsterfunktion som returnerar ett kluster-ID för varje indatageometri med hjälp av DBSCAN-algoritmen.
integer ST_ClusterDBSCAN(geometry winset geom, float8 eps, integer minpoints);
En fönsterfunktion som returnerar ett klusternummer för varje indatageometri med hjälp av DBSCAN-algoritmen ( 2D Density-based spatial clustering of applications with noise). Till skillnad från ST_ClusterKMeans kräver den inte att antalet kluster anges, utan använder istället parametrarna för önskat avstånd(eps) och densitet(minpoints) för att bestämma varje kluster.
En indatageometri läggs till i ett kluster om den är antingen:
Observera att gränsgeometrier kan ligga inom eps-avstånd från kärngeometrier i mer än ett kluster. Båda tilldelningarna skulle vara korrekta, så gränsgeometrin kommer godtyckligt att tilldelas ett av de tillgängliga klustren. I den här situationen är det möjligt att ett korrekt kluster genereras med färre än minpunktsgeometrier. För att säkerställa deterministisk tilldelning av gränsgeometrier (så att upprepade anrop till ST_ClusterDBSCAN ger identiska resultat), använd en ORDER BY-klausul i fönsterdefinitionen. Tvetydiga klustertilldelningar kan skilja sig från andra DBSCAN-implementeringar.
![]() | |
Geometrier som inte uppfyller kriterierna för att ingå i något kluster tilldelas ett klusternummer som är NULL. |
Tillgänglighet: 2.3.0
Denna metod stöder cirkulära strängar och kurvor.
Cluster polygons within 50 units of each other, requiring at least two polygons per cluster. The isolated polygon is reported as noise.
WITH input(name, geom) AS (
VALUES
('A1', ST_MakeEnvelope(0, 0, 10, 10)),
('A2', ST_MakeEnvelope(30, 0, 40, 10)),
('B1', ST_MakeEnvelope(100, 0, 110, 10)),
('B2', ST_MakeEnvelope(130, 0, 140, 10)),
('noise', ST_MakeEnvelope(250, 0, 260, 10))
), clustered AS (
SELECT name,
geom,
ST_ClusterDBSCAN(geom, eps => 50, minpoints => 2)
OVER (ORDER BY name) AS cid
FROM input
)
SELECT COALESCE(cid::text, 'noise') AS cluster,
string_agg(name, ',' ORDER BY name) AS members,
ST_Collect(geom ORDER BY name) AS cluster_geom
FROM clustered
GROUP BY cid
ORDER BY cid NULLS LAST;0 | A1,A2 | MULTIPOLYGON(((0 0,0 10,10 10,10 0,0 0)),((30 0,30 10,40 10,40 0,30 0))) 1 | B1,B2 | MULTIPOLYGON(((100 0,100 10,110 10,110 0,100 0)),((130 0,130 10,140 10,140 0,130 0))) noise | noise | MULTIPOLYGON(((250 0,250 10,260 10,260 0,250 0)))
Ett exempel som visar hur man kombinerar skiften med samma klusternummer till geometriska samlingar.
SELECT cid, ST_Collect(geom) AS cluster_geom, array_agg(parcel_id) AS ids_in_cluster FROM (
SELECT parcel_id, ST_ClusterDBSCAN(geom, eps => 0.5, minpoints => 5) over () AS cid, geom
FROM parcels) sq
GROUP BY cid;
ST_ClusterIntersecting — Aggregerad funktion som klustrar inmatade geometrier till sammanhängande mängder.
geometry[] ST_ClusterIntersecting(geometry set g);
En aggregerad funktion som returnerar en array av GeometryCollections som delar upp indatageometrierna i sammanhängande kluster som är disjunkta. Varje geometri i ett kluster skär minst en annan geometri i klustret, och skär inte någon geometri i andra kluster.
Tillgänglighet: 2.2.0
WITH testdata AS
(SELECT unnest(
ARRAY['LINESTRING (0 0,1 1)'::geometry,
'LINESTRING (5 5,4 4)'::geometry,
'LINESTRING (6 6,7 7)'::geometry,
'LINESTRING (0 0,-1 -1)'::geometry,
'POLYGON ((0 0,4 0,4 4,0 4,0 0))'::geometry]) AS geom)
SELECT unnest(ST_ClusterIntersecting(geom)) FROM testdata;
GEOMETRYCOLLECTION(LINESTRING(0 0,1 1),LINESTRING(5 5,4 4),LINESTRING(0 0,-1 -1),POLYGON((0 0,4 0,4 4,0 4,0 0))) GEOMETRYCOLLECTION(LINESTRING(6 6,7 7))
ST_ClusterIntersectingWin — Fönsterfunktion som returnerar ett kluster-ID för varje indatageometri och klustrar indatageometrier i sammanhängande uppsättningar.
integer ST_ClusterIntersectingWin(geometry winset geom);
En fönsterfunktion som bygger sammanhängande kluster av geometrier som korsar varandra. Det är möjligt att traversera alla geometrier i ett kluster utan att lämna klustret. Returvärdet är det klusternummer som geometriargumentet deltar i, eller null för null-indata.
Tillgänglighet: 3.4.0
Return an explicit cluster id for each input geometry. Using the conventional cid alias keeps the geometry column ready for color-by-cluster rendering.
WITH testdata(id, geom) AS (
VALUES (1, 'LINESTRING (0 0,1 1)'::geometry),
(2, 'LINESTRING (5 5,4 4)'::geometry),
(3, 'LINESTRING (6 6,7 7)'::geometry),
(4, 'LINESTRING (0 0,-1 -1)'::geometry),
(5, 'POLYGON ((0 0,4 0,4 4,0 4,0 0))'::geometry)
), clustered AS (
SELECT id,
geom,
ST_ClusterIntersectingWin(geom) OVER () AS cid
FROM testdata
)
SELECT id,
geom AS geom_wkt,
cid
FROM clustered
ORDER BY id;id | geom_wkt | cid ----+--------------------------------+----- 1 | LINESTRING(0 0,1 1) | 0 2 | LINESTRING(5 5,4 4) | 0 3 | LINESTRING(6 6,7 7) | 1 4 | LINESTRING(0 0,-1 -1) | 0 5 | POLYGON((0 0,4 0,4 4,0 4,0 0)) | 0
ST_ClusterRelateWin — Window function that returns a cluster id for each input geometry, clustering input geometries into connected sets using the relate pattern to determine whether the geometries are connected.
integer ST_ClusterRelateWin(geometry winset geom, text relate_matrix);
A window function that builds connected clusters of geometries that intersect. Geometries are added to a cluster if they share a pairwise DE9IM relationship with another member of the cluster. With this function it is possible to build a cluster of all objects that touch at boundaries, but exclude those that merely overlap.
Availability: 3.7.0
This collection of line strings would form a single cluster using ST_ClusterIntersectingWin, but using ST_ClusterRelateWin can be clustered into three groups that connect only via their end points.
WITH data(id, geom) AS (
VALUES (1, 'LINESTRING(0 0,1 1)'::geometry),
(2, 'LINESTRING(2 2,1 1)'::geometry),
(3, 'LINESTRING(0 1,1 0)'::geometry),
(4, 'LINESTRING(0 1,0 4)'::geometry),
(5, 'LINESTRING(2 2,2 4)'::geometry),
(6, 'LINESTRING(1.5 2.5,2.5 3.5)'::geometry)
), clustered AS (
SELECT id, geom,
ST_ClusterRelateWin(geom, '****0****') OVER () AS cluster
FROM data
)
SELECT cluster,
string_agg(id::text, ',' ORDER BY id) AS members,
ST_Collect(geom ORDER BY id) AS cluster_geom
FROM clustered
GROUP BY cluster
ORDER BY cluster;0 | 1,2,5 | MULTILINESTRING((0 0,1 1),(2 2,1 1),(2 2,2 4)) 1 | 3,4 | MULTILINESTRING((0 1,1 0),(0 1,0 4)) 2 | 6 | MULTILINESTRING((1.5 2.5,2.5 3.5))
ST_MinimumSpanningTree — Window function that returns a tree id for each input geometry, clustering input geometries into connected trees using the Minimum Spanning Tree algorithm.
integer ST_MinimumSpanningTree(geometry winset geom);
A window function that builds connected graphs of line strings based on the Minimum Spanning Tree (MST) of the input geometries. The return value is the cluster number that the geometry argument participates in, or zero if it is not part of the minimum tree.
The Minimum Spanning Tree connects all geometries in the window partition such that the total length of the connecting lines is minimized. If the graph is not fully connected (e.g. infinite distance between some geometries), it produces a Minimum Spanning Forest, and each connected component is assigned a unique tree ID.
Availability: 3.7.0
Requires GEOS >= 3.15.0
These six edges describe a square with both diagonals. The minimum spanning tree keeps three edges and excludes the rest.
WITH edges(id, geom) AS (
VALUES
(1, 'LINESTRING(0 0,1 0)'::geometry),
(2, 'LINESTRING(0 0,0 1)'::geometry),
(3, 'LINESTRING(1 1,0 1)'::geometry),
(4, 'LINESTRING(1 1,1 0)'::geometry),
(5, 'LINESTRING(0 0,1 1)'::geometry),
(6, 'LINESTRING(1 0,0 1)'::geometry)
), marked AS (
SELECT id,
geom,
ST_MinimumSpanningTree(geom) OVER (ORDER BY id) AS tree_id
FROM edges
)
SELECT string_agg(id::text, ',' ORDER BY id)
FILTER (WHERE tree_id > 0) AS tree_edge_ids,
ST_Collect(geom ORDER BY id)
FILTER (WHERE tree_id > 0) AS tree_edges,
string_agg(id::text, ',' ORDER BY id)
FILTER (WHERE tree_id = 0) AS excluded_edge_ids,
ST_Collect(geom ORDER BY id)
FILTER (WHERE tree_id = 0) AS excluded_edges
FROM marked;-[ RECORD 1 ]----- tree_edge_ids | 1,2,3 tree_edges | MULTILINESTRING((0 0,1 0),(0 0,0 1),(1 1,0 1)) excluded_edge_ids | 4,5,6 excluded_edges | MULTILINESTRING((1 1,1 0),(0 0,1 1),(1 0,0 1))
ST_ClusterKMeans — Fönsterfunktion som returnerar ett kluster-ID för varje indatageometri med hjälp av K-means-algoritmen.
integer ST_ClusterKMeans( geometry winset geom , integer k , float8 max_radius );
Returnerar K-means klusternummer för varje indatageometri. Avståndet som används för klustring är avståndet mellan centroiderna för 2D-geometrier och avståndet mellan bounding box-centren för 3D-geometrier. För POINT-indata kommer M-koordinaten att behandlas som indataens vikt och måste vara större än 0.
max_radius, om den är inställd, gör att ST_ClusterKMeans genererar fler kluster än k och säkerställer att inget kluster i utdata har en radie som är större än max_radius. Detta är användbart vid räckviddsanalys.
Förbättrad: 3.2.0 Stöd för max_radius
Förbättrad: 3.1.0 Stöd för 3D-geometrier och vikter
Tillgänglighet: 2.3.0
Define the parcel geometries once in a CTE and reuse them across the executable examples.
Parcels color-coded by cluster number (cid).
WITH parcels(parcel_id, geom) AS (
VALUES
('A1', ST_MakeEnvelope(0, 0, 10, 10)),
('A2', ST_MakeEnvelope(10, 0, 20, 10)),
('B1', ST_MakeEnvelope(100, 0, 110, 10)),
('B2', ST_MakeEnvelope(110, 0, 120, 10)),
('C1', ST_MakeEnvelope(200, 0, 210, 10)),
('C2', ST_MakeEnvelope(210, 0, 220, 10))
), clustered AS (
SELECT parcel_id,
geom,
ST_ClusterKMeans(geom, 3) OVER (ORDER BY parcel_id) AS cid
FROM parcels
)
SELECT cid,
string_agg(parcel_id, ',' ORDER BY parcel_id) AS parcels,
ST_Union(geom) AS cluster_geom
FROM clustered
GROUP BY cid
ORDER BY cid;0 | C1,C2 | POLYGON((200 10,210 10,220 10,220 0,210 0,200 0,200 10)) 1 | A1,A2 | POLYGON((0 10,10 10,20 10,20 0,10 0,0 0,0 10)) 2 | B1,B2 | POLYGON((100 10,110 10,120 10,120 0,110 0,100 0,100 10))
Uppdelning av paketkluster efter typ:
WITH parcel_geoms AS (
SELECT geom
FROM ST_Subdivide(
ST_Buffer('SRID=3857;LINESTRING(40 100,98 100,100 150,60 90)'::geometry,
40, 'endcap=square'),
12) AS geom
), parcels AS (
SELECT lpad(row_number() OVER (ORDER BY ST_YMin(geom), ST_XMin(geom))::text, 3, '0') AS parcel_id,
geom,
('{residential,commercial}'::text[])[1 + mod(row_number() OVER (ORDER BY ST_YMin(geom), ST_XMin(geom)), 2)] AS type
FROM parcel_geoms
)
SELECT ST_ClusterKMeans(geom, 3) over (PARTITION BY type) AS cid,
parcel_id,
type,
ST_SnapToGrid(geom, 1) AS parcel_geom
FROM parcels
ORDER BY type, parcel_id;cid | parcel_id | type | parcel_geom -----+-----------+-------------+-------------------------------------------------------------- 0 | 001 | commercial | POLYGON((33 60,0 60,0 98,71 98,71 35,33 60)) 2 | 003 | commercial | POLYGON((106 98,138 98,137 91,134 84,131 77,126 71,120 66,113 63,106 61,106 98)) 2 | 005 | commercial | POLYGON((140 148,138 98,72 98,72 148,140 148)) 1 | 007 | commercial | POLYGON((109 189,116 187,123 183,129 178,134 171,137 164,139 156,140 148,109 148,109 189)) 0 | 002 | residential | POLYGON((71 98,106 98,106 61,98 60,88 60,71 35,71 98)) 2 | 004 | residential | POLYGON((0 98,0 140,45 140,67 172,72 178,72 98,0 98)) 1 | 006 | residential | POLYGON((72 178,78 183,85 187,93 189,101 190,109 189,109 148,72 148,72 178))
Example: Clustering a preaggregated planetary-scale data population dataset using 3D clustering and weighting. Identify at least 20 regions based on Kontur Population Data that do not span more than 3000 km from their center:
CREATE TABLE kontur_population_3000km_clusters AS
SELECT
geom,
ST_ClusterKMeans(
ST_Force4D(
ST_Transform(ST_Force3D(geom), 4978),
mvalue => population
),
20,
max_radius => 3000000
) OVER () AS cid
FROM kontur_population;The clustering produces 46 regions. Clusters are centered at well-populated regions such as New York and Moscow. Greenland forms one cluster, several island clusters span the antimeridian, and cluster edges follow the Earth's curvature.

Kontur population clustered with 3000 km maximum radius.
Cluster weighted city populations on the Earth in geocentric coordinates. The maximum radius is specified in meters, while the returned geometries stay in WGS 84 for display.
WITH population(place, population, geom) AS (
VALUES
('Boston', 5.0, ST_SetSRID(ST_Point(-71.06, 42.36), 4326)),
('New York', 20.0, ST_SetSRID(ST_Point(-74.01, 40.71), 4326)),
('London', 15.0, ST_SetSRID(ST_Point(-0.13, 51.51), 4326)),
('Paris', 11.0, ST_SetSRID(ST_Point(2.35, 48.86), 4326)),
('Osaka', 19.0, ST_SetSRID(ST_Point(135.50, 34.69), 4326)),
('Tokyo', 37.0, ST_SetSRID(ST_Point(139.69, 35.68), 4326)),
('Melbourne', 5.0, ST_SetSRID(ST_Point(144.96, -37.81), 4326)),
('Sydney', 5.0, ST_SetSRID(ST_Point(151.21, -33.87), 4326))
), clustered AS (
SELECT place,
geom,
ST_ClusterKMeans(
ST_Force4D(
ST_Transform(ST_Force3D(geom), 4978),
mvalue => population
),
4,
max_radius => 3000000
) OVER (ORDER BY place) AS cid
FROM population
)
SELECT cid,
string_agg(place, ', ' ORDER BY place) AS places,
ST_Collect(geom ORDER BY place) AS cluster_geom
FROM clustered
GROUP BY cid
ORDER BY cid;0 | Melbourne, Sydney | MULTIPOINT((144.96 -37.81),(151.21 -33.87)) 1 | Boston, New York | MULTIPOINT((-71.06 42.36),(-74.01 40.71)) 2 | Osaka, Tokyo | MULTIPOINT((135.5 34.69),(139.69 35.68)) 3 | London, Paris | MULTIPOINT((-0.13 51.51),(2.35 48.86))
ST_ClusterWithin — Aggregatfunktion som klustrar geometrier efter separationsavstånd.
geometry[] ST_ClusterWithin(geometry set g, float8 distance);
En aggregerad funktion som returnerar en array av GeometryCollections, där varje samling är ett kluster som innehåller vissa indatageometrier. Klustring delar in indatageometrierna i uppsättningar där varje geometri ligger inom det angivna avståndet från minst en annan geometri i samma kluster. Avstånden är kartesiska avstånd i SRID:ens enheter.
ST_ClusterWithin är likvärdigt med att köra ST_ClusterDBSCAN med minpoints=> 0.
Tillgänglighet: 2.2.0
Denna metod stöder cirkulära strängar och kurvor.
WITH testdata AS
(SELECT unnest(ARRAY['LINESTRING (0 0,1 1)'::geometry,
'LINESTRING (5 5,4 4)'::geometry,
'LINESTRING (6 6,7 7)'::geometry,
'LINESTRING (0 0,-1 -1)'::geometry,
'POLYGON ((0 0,4 0,4 4,0 4,0 0))'::geometry]) AS geom)
SELECT unnest(ST_ClusterWithin(geom, 1.4)) FROM testdata;
GEOMETRYCOLLECTION(LINESTRING(0 0,1 1),LINESTRING(5 5,4 4),LINESTRING(0 0,-1 -1),POLYGON((0 0,4 0,4 4,0 4,0 0))) GEOMETRYCOLLECTION(LINESTRING(6 6,7 7))
ST_ClusterWithinWin — Fönsterfunktion som returnerar ett kluster-ID för varje indatageometri, klustring med hjälp av separationsavstånd.
integer ST_ClusterWithinWin(geometry winset geom, float8 distance);
En fönsterfunktion som returnerar ett klusternummer för varje indatageometri. Klusterindelningen delar in geometrierna i uppsättningar där varje geometri ligger inom det angivna avståndet från minst en annan geometri i samma kluster. Avstånden är kartesiska avstånd i SRID-enheterna.
ST_ClusterWithinWin är likvärdigt med att köra ST_ClusterDBSCAN med minpoints=> 0.
Tillgänglighet: 3.4.0
Denna metod stöder cirkulära strängar och kurvor.
WITH testdata AS (
SELECT id, geom::geometry FROM (
VALUES (1, 'LINESTRING (0 0,1 1)'),
(2, 'LINESTRING (5 5,4 4)'),
(3, 'LINESTRING (6 6,7 7)'),
(4, 'LINESTRING (0 0,-1 -1)'),
(5, 'POLYGON ((0 0,4 0,4 4,0 4,0 0))')) AS t(id, geom)
)
SELECT id,
geom,
ST_ClusterWithinWin(geom, 1.4) OVER () AS cluster
FROM testdata;id | st_astext | cluster ----+--------------------------------+--------- 1 | LINESTRING(0 0,1 1) | 0 2 | LINESTRING(5 5,4 4) | 0 3 | LINESTRING(6 6,7 7) | 1 4 | LINESTRING(0 0,-1 -1) | 0 5 | POLYGON((0 0,4 0,4 4,0 4,0 0)) | 0
Dessa funktioner producerar eller arbetar med begränsningsboxar. De kan också tillhandahålla och acceptera geometrivärden genom att använda automatiska eller explicita casts.
Box2D — Returnerar en BOX2D som representerar 2D-utbredningen av en geometri.
box2d Box2D(geometry geom);
Returnerar en box2d som representerar geometrins 2D-utbredning.
Förbättrad: 2.0.0 stöd för polyhedrala ytor, trianglar och TIN infördes.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
SELECT Box2D('LINESTRING(1 2,3 4,5 6)'::geometry);BOX(1 2,5 6)
SELECT Box2D('CIRCULARSTRING(220268 150415,220227 150505,220227 150406)'::geometry);BOX(220186.99512189245 150406,220288.24878054656 150506.12682932706)
Box3D — Returnerar en BOX3D som representerar 3D-utbredningen av en geometri.
box3d Box3D(geometry geom);
Returnerar en box3d som representerar geometrins 3D-utbredning.
Förbättrad: 2.0.0 stöd för polyhedrala ytor, trianglar och TIN infördes.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
Denna funktion stöder 3d och kommer inte att tappa z-index.
SELECT Box3D('LINESTRING(1 2 3,3 4 5,5 6 5)'::geometry);BOX3D(1 2 3,5 6 5)
SELECT Box3D('CIRCULARSTRING(220268 150415 1,220227 150505 1,220227 150406 1)'::geometry);BOX3D(220186.99512189245 150406 1,220288.24878054656 150506.12682932706 1)
ST_EstimatedExtent — Returnerar den uppskattade omfattningen av en spatial tabell.
box2d ST_EstimatedExtent(text schema_name, text table_name, text geocolumn_name, boolean parent_only);
box2d ST_EstimatedExtent(text schema_name, text table_name, text geocolumn_name);
box2d ST_EstimatedExtent(text table_name, text geocolumn_name);
Returnerar den beräknade omfattningen av en spatial tabell som en box2d. Det aktuella schemat används om det inte anges. Den uppskattade omfattningen hämtas från geometrikolumnens statistik. Detta är vanligtvis mycket snabbare än att beräkna den exakta omfattningen av tabellen med ST_Extent eller ST_3DExtent.
Standardbeteendet är att även använda statistik som samlats in från underordnade tabeller (tabeller med INHERITS) om sådan finns tillgänglig. Om parent_only är satt till TRUE används endast statistik för den angivna tabellen och underordnade tabeller ignoreras.
För PostgreSQL> = 8.0.0 samlas statistik in av VACUUM ANALYZE och resultatomfattningen kommer att vara cirka 95% of den faktiska. För PostgreSQL <8.0.0 samlas statistik genom att köra update_geometry_stats () och resultatomfattningen är exakt.
![]() | |
Om det inte finns någon statistik (tom tabell eller ingen ANALYZE anropad) returnerar denna funktion NULL. Före version 1.5.4 kastades ett undantag i stället. |
![]() | |
Escaping av namn för tabeller och/eller namnrymder som innehåller specialtecken och citattecken kan kräva särskild hantering. En användare noterar: "För scheman och tabeller, använd identifieringsregler för escaping för att producera en dubbelciterad sträng och ta sedan bort det första och sista dubbelciteringstecknet. För geometrikolumner, skicka som de är." |
Tillgänglighet: 1.0.0
Ändrad: 2.1.0. Fram till 2.0.x kallades detta ST_Estimated_Extent.
Denna metod stöder cirkulära strängar och kurvor.
SELECT ST_EstimatedExtent('ny', 'edges', 'geom');st_estimatedextent -------------------------------------------------- BOX(-8877653 4912316,-8010225.5 5589284) (1 row)
SELECT ST_EstimatedExtent('feature_poly', 'geom');st_estimatedextent --------------------------------------------------------------------- BOX(-124.659652709961 24.6830825805664,-67.7798080444336 49.0012092590332) (1 row)
ST_Expand — Returnerar en bounding box som expanderats från en annan bounding box eller en geometri.
geometry ST_Expand(geometry geom, float units_to_expand);
geometry ST_Expand(geometry geom, float dx, float dy, float dz=0, float dm=0);
box2d ST_Expand(box2d box, float units_to_expand);
box2d ST_Expand(box2d box, float dx, float dy);
box3d ST_Expand(box3d box, float units_to_expand);
box3d ST_Expand(box3d box, float dx, float dy, float dz=0);
Returnerar en bounding box som expanderats från indatans bounding box, antingen genom att ange ett enda avstånd med vilket boxen ska expanderas på båda axlarna, eller genom att ange ett expansionsavstånd för varje axel. Använder dubbel precision. Kan användas för avståndsfrågor eller för att lägga till ett bounding box-filter i en fråga för att dra nytta av ett spatialt index.
Förutom den version av ST_Expand som accepterar och returnerar en geometri, finns det varianter som accepterar och returnerar datatyperna box2d och box3d.
Avstånden anges i enheterna i det spatiala referenssystemet för inmatningen.
ST_Expand liknar ST_Buffer, men medan buffring expanderar en geometri i alla riktningar, expanderar ST_Expand den avgränsande rutan längs varje axel.
![]() | |
Före version 1.3 användes ST_Expand tillsammans med ST_Distance för att göra indexerbara avståndsfrågor. Till exempel |
Tillgänglighet: 1.5.0 ändrat beteende för att mata ut dubbel precision istället för float4-koordinater.
Förbättrad: 2.0.0 stöd för polyhedrala ytor, trianglar och TIN infördes.
Förbättrad: 2.3.0 stöd har lagts till för att expandera en ruta med olika belopp i olika dimensioner.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
![]() | |
Exemplen nedan använder US National Atlas Equal Area (SRID=2163) som är en meterprojektion |
10-meter expanded box around bbox of a linestring.
SELECT CAST(ST_Expand(ST_GeomFromText('LINESTRING(2312980 110676,2312923 110701,2312892 110714)', 2163), 10) As box2d);BOX(2312882 110666,2312990 110724)
This example expands a 3D box by 10 meters.
SELECT ST_Expand(CAST('BOX3D(778783 2951741 1,794875 2970042.61545891 10)' AS box3d), 10)BOX3D(778773 2951731 -9,794885 2970052.61545891 20)
This example renders the text representation of a 10-meter expanded box around a point geometry.
SELECT ST_Expand('SRID=2163;POINT(2312980 110676)'::geometry, 10);SRID=2163;POLYGON((2312970 110666,2312970 110686,2312990 110686,2312990 110666,2312970 110666))
ST_Extent — Aggregerad funktion som returnerar geometriernas avgränsande box.
box2d ST_Extent(geometry set geomfield);
En aggregerad funktion som returnerar en box2d bounding box som avgränsar en uppsättning geometrier.
Koordinaterna för begränsningsrutan är i det spatiala referenssystemet för de inmatade geometrierna.
ST_Extent är ett liknande koncept som Oracle Spatial/Locators SDO_AGGR_MBR.
![]() | |
ST_Extent returnerar rutor med endast X- och Y-ordinater även med 3D-geometrier. Om du vill returnera XYZ-ordinater använder du ST_3DExtent. |
![]() | |
Det returnerade |
Förbättrad: 2.0.0 stöd för polyhedrala ytor, trianglar och TIN infördes.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
![]() | |
I exemplen nedan används Massachusetts State Plane ft (SRID=2249) |
SELECT ST_Extent(geom) AS bextent FROM sometable;
BOX(739651.875 2908247.25,794875.8125 2970042.75)
Return extent of each geometry category.
SELECT ST_Extent(geom) as bextent FROM sometable GROUP BY category ORDER BY category;
bextent | name ----------------------------------------------------+---------------- BOX(778783.5625 2951741.25,794875.8125 2970042.75) | A BOX(751315.8125 2919164.75,765202.6875 2935417.25) | B BOX(739651.875 2917394.75,756688.375 2935866) | C
This example converts the extent back into a geometry and renders its extended text representation.
SELECT ST_SetSRID(ST_Extent(geom), 2249) AS bextent FROM sometable;
SRID=2249;POLYGON((739651.875 2908247.25,739651.875 2970042.75,794875.8125 2970042.75,
794875.8125 2908247.25,739651.875 2908247.25))
ST_3DExtent — Aggregerad funktion som returnerar geometriernas 3D-begränsningsbox.
box3d ST_3DExtent(geometry set geomfield);
En aggregerad funktion som returnerar en box3d (inkluderar Z-ordinat) avgränsningsbox som avgränsar en uppsättning geometrier.
Koordinaterna för begränsningsrutan är i det spatiala referenssystemet för de inmatade geometrierna.
![]() | |
Det returnerade |
Förbättrad: 2.0.0 stöd för polyhedrala ytor, trianglar och TIN infördes.
Ändrad: 2.0.0 I tidigare versioner hette detta ST_Extent3D
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
SELECT ST_3DExtent(foo.geom) As b3extent
FROM (SELECT ST_MakePoint(x, y, z) As geom
FROM generate_series(1, 3) As x
CROSS JOIN generate_series(1, 2) As y
CROSS JOIN generate_series(0, 2) As Z) As foo;BOX3D(1 1 0,3 2 2)
This example returns the extent of several elevated CircularStrings.
SELECT ST_3DExtent(foo.geom) As b3extent
FROM (SELECT ST_Translate(ST_Force3DZ(ST_LineToCurve(ST_Buffer(ST_Point(x, y), 1))), 0, 0, z) As geom
FROM generate_series(1, 3) As x
CROSS JOIN generate_series(1, 2) As y
CROSS JOIN generate_series(0, 2) As Z) As foo;BOX3D(0 0 0,4 3 2)
ST_MakeBox2D — Skapar en BOX2D som definieras av två 2D-punktgeometrier.
box2d ST_MakeBox2D(geometry pointLowLeft, geometry pointUpRight);
Skapar en box2d som definieras av två punktgeometrier. Detta är användbart för att göra intervallfrågor.
Return all features that fall within or partly reside in a US National Atlas coordinate bounding box. It is assumed here that the geometries are stored with SRID=2163 (US National Atlas equal area).
SELECT feature_id, feature_name, geom
FROM features
WHERE geom && ST_SetSRID(
ST_MakeBox2D(
ST_Point(-989502.1875, 528439.5625),
ST_Point(-987121.375, 529933.1875)
),
2163
);
ST_3DMakeBox — Skapar en BOX3D som definieras av två 3D-punktgeometrier.
box3d ST_3DMakeBox(geometry point3DLowLeftBottom, geometry point3DUpRightTop);
Skapar en box3d som definieras av två 3D-punktgeometrier.
Denna funktion stöder 3D och släpper inte z-index.
Ändrad: 2.0.0 I tidigare versioner brukade detta kallas ST_MakeBox3D
SELECT ST_3DMakeBox(ST_MakePoint(-989502.1875, 528439.5625, 10),
ST_MakePoint(-987121.375 , 529933.1875, 10))BOX3D(-989502.1875 528439.5625 10,-987121.375 529933.1875 10)
ST_XMax — Returnerar X-maximum för en 2D- eller 3D-begränsningsbox eller en geometri.
float ST_XMax(box3d aGeomorBox2DorBox3D);
Returnerar X-maximum för en 2D- eller 3D-begränsningsbox eller en geometri.
![]() | |
Även om denna funktion endast är definierad för box3d fungerar den också för box2d- och geometrivärden på grund av automatisk casting. Den kommer dock inte att acceptera en geometri- eller box2d-textrepresentation, eftersom dessa inte har automatisk casting. |
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
SELECT ST_XMax('BOX3D(1 2 3,4 5 6)');4
SELECT ST_XMax('LINESTRING(1 3 4,5 6 7)'::geometry);5
SELECT ST_XMax(CAST('BOX(-3 2,3 4)' AS box2d));3
Observe THIS DOES NOT WORK because it will try to auto-cast the string representation to a BOX3D.
SELECT ST_XMax('LINESTRING(1 3,5 6)');ERROR: BOX3D parser - doesn't start with BOX3D(
SELECT ST_XMax('CIRCULARSTRING(220268 150415 1,220227 150505 2,220227 150406 3)'::geometry);220288.248780547
ST_XMin — Returnerar X-minima för en 2D- eller 3D-begränsningsbox eller en geometri.
float ST_XMin(box3d aGeomorBox2DorBox3D);
Returnerar X-minima för en 2D- eller 3D-begränsningsbox eller en geometri.
![]() | |
Även om denna funktion endast är definierad för box3d, fungerar den även för box2d- och geometrivärden på grund av automatisk casting. Den kommer dock inte att acceptera en geometri- eller box2d-textrepresentation, eftersom dessa inte har automatisk casting. |
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
SELECT ST_XMin('BOX3D(1 2 3,4 5 6)');1
SELECT ST_XMin('LINESTRING(1 3 4,5 6 7)'::geometry);1
SELECT ST_XMin(CAST('BOX(-3 2,3 4)' AS box2d));-3
Observe THIS DOES NOT WORK because it will try to auto-cast the string representation to a BOX3D.
SELECT ST_XMin('LINESTRING(1 3,5 6)');ERROR: BOX3D parser - doesn't start with BOX3D(
SELECT ST_XMin('CIRCULARSTRING(220268 150415 1,220227 150505 2,220227 150406 3)'::geometry);220186.995121892
ST_YMax — Returnerar Y-maximum för en 2D- eller 3D-begränsningsbox eller en geometri.
float ST_YMax(box3d aGeomorBox2DorBox3D);
Returnerar Y-maximum för en 2D- eller 3D-begränsningsbox eller en geometri.
![]() | |
Även om denna funktion endast är definierad för box3d, fungerar den även för box2d- och geometrivärden på grund av automatisk casting. Den kommer dock inte att acceptera en geometri- eller box2d-textrepresentation, eftersom dessa inte har automatisk casting. |
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
SELECT ST_YMax('BOX3D(1 2 3,4 5 6)');5
SELECT ST_YMax('LINESTRING(1 3 4,5 6 7)'::geometry);6
SELECT ST_YMax(CAST('BOX(-3 2,3 4)' AS box2d));4
Observe THIS DOES NOT WORK because it will try to auto-cast the string representation to a BOX3D.
SELECT ST_YMax('LINESTRING(1 3,5 6)');ERROR: BOX3D parser - doesn't start with BOX3D(
SELECT ST_YMax('CIRCULARSTRING(220268 150415 1,220227 150505 2,220227 150406 3)'::geometry);150506.126829327
ST_YMin — Returnerar Y-minima för en 2D- eller 3D-begränsningsbox eller en geometri.
float ST_YMin(box3d aGeomorBox2DorBox3D);
Returnerar Y-minima för en 2D- eller 3D-begränsningsbox eller en geometri.
![]() | |
Även om denna funktion endast är definierad för box3d, fungerar den även för box2d- och geometrivärden på grund av automatisk casting. Den kommer dock inte att acceptera en geometri- eller box2d-textrepresentation, eftersom dessa inte har automatisk casting. |
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
SELECT ST_YMin('BOX3D(1 2 3,4 5 6)');2
SELECT ST_YMin('LINESTRING(1 3 4,5 6 7)'::geometry);3
SELECT ST_YMin(CAST('BOX(-3 2,3 4)' AS box2d));2
Observe THIS DOES NOT WORK because it will try to auto-cast the string representation to a BOX3D.
SELECT ST_YMin('LINESTRING(1 3,5 6)');ERROR: BOX3D parser - doesn't start with BOX3D(
SELECT ST_YMin('CIRCULARSTRING(220268 150415 1,220227 150505 2,220227 150406 3)'::geometry);150406
ST_ZMax — Returnerar Z-maximum för en 2D- eller 3D-begränsningsbox eller en geometri.
float ST_ZMax(box3d aGeomorBox2DorBox3D);
Returnerar Z-maximum för en 2D- eller 3D-begränsningsbox eller en geometri.
![]() | |
Även om denna funktion endast är definierad för box3d, fungerar den även för box2d- och geometrivärden på grund av automatisk casting. Den kommer dock inte att acceptera en geometri- eller box2d-textrepresentation, eftersom dessa inte har automatisk casting. |
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
SELECT ST_ZMax('BOX3D(1 2 3,4 5 6)');6
SELECT ST_ZMax('LINESTRING(1 3 4,5 6 7)'::geometry);7
SELECT ST_ZMax('BOX3D(-3 2 1,3 4 1)');1
Observe THIS DOES NOT WORK because it will try to auto-cast the string representation to a BOX3D.
SELECT ST_ZMax('LINESTRING(1 3 4,5 6 7)');ERROR: BOX3D parser - doesn't start with BOX3D(
SELECT ST_ZMax('CIRCULARSTRING(220268 150415 1,220227 150505 2,220227 150406 3)'::geometry);3
ST_ZMin — Returnerar Z-minima för en 2D- eller 3D-begränsningsbox eller en geometri.
float ST_ZMin(box3d aGeomorBox2DorBox3D);
Returnerar Z-minima för en 2D- eller 3D-begränsningsbox eller en geometri.
![]() | |
Även om denna funktion endast är definierad för box3d, fungerar den även för box2d- och geometrivärden på grund av automatisk casting. Den kommer dock inte att acceptera en geometri- eller box2d-textrepresentation, eftersom dessa inte har automatisk casting. |
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
SELECT ST_ZMin('BOX3D(1 2 3,4 5 6)');3
SELECT ST_ZMin('LINESTRING(1 3 4,5 6 7)'::geometry);4
SELECT ST_ZMin('BOX3D(-3 2 1,3 4 1)');1
Observe THIS DOES NOT WORK because it will try to auto-cast the string representation to a BOX3D.
SELECT ST_ZMin('LINESTRING(1 3 4,5 6 7)');ERROR: BOX3D parser - doesn't start with BOX3D(
SELECT ST_ZMin('CIRCULARSTRING(220268 150415 1,220227 150505 2,220227 150406 3)'::geometry);1
ST_GeomFromEWKT, ST_GeomFromText, ST_XMin, ST_XMax, ST_YMin, ST_YMax, ST_ZMax, ST_MMin, ST_MMax
ST_XSize — Returns the X size of a 2D or 3D bounding box or a geometry.
float ST_XSize(box3d aGeomorBox2DorBox3D);
Returns the X size of a 2D or 3D bounding box or a geometry, computed as ST_XMax(aGeomorBox2DorBox3D) - ST_XMin(aGeomorBox2DorBox3D).
![]() | |
Även om denna funktion endast är definierad för box3d, fungerar den även för box2d- och geometrivärden på grund av automatisk casting. Den kommer dock inte att acceptera en geometri- eller box2d-textrepresentation, eftersom dessa inte har automatisk casting. |
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
Availability: 3.7.0
SELECT ST_XSize('BOX3D(1 2 3,4 5 6)');3
SELECT ST_XSize('LINESTRING(1 3,5 6)'::geometry);4
ST_YSize — Returns the Y size of a 2D or 3D bounding box or a geometry.
float ST_YSize(box3d aGeomorBox2DorBox3D);
Returns the Y size of a 2D or 3D bounding box or a geometry, computed as ST_YMax(aGeomorBox2DorBox3D) - ST_YMin(aGeomorBox2DorBox3D).
![]() | |
Även om denna funktion endast är definierad för box3d, fungerar den även för box2d- och geometrivärden på grund av automatisk casting. Den kommer dock inte att acceptera en geometri- eller box2d-textrepresentation, eftersom dessa inte har automatisk casting. |
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
Availability: 3.7.0
SELECT ST_YSize('BOX3D(1 2 3,4 5 6)');3
SELECT ST_YSize('LINESTRING(1 3,5 6)'::geometry);3
ST_ZSize — Returns the Z size of a 2D or 3D bounding box or a geometry.
float ST_ZSize(box3d aGeomorBox2DorBox3D);
Returns the Z size of a 2D or 3D bounding box or a geometry, computed as ST_ZMax(aGeomorBox2DorBox3D) - ST_ZMin(aGeomorBox2DorBox3D).
![]() | |
Även om denna funktion endast är definierad för box3d, fungerar den även för box2d- och geometrivärden på grund av automatisk casting. Den kommer dock inte att acceptera en geometri- eller box2d-textrepresentation, eftersom dessa inte har automatisk casting. |
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
Availability: 3.7.0
SELECT ST_ZSize('BOX3D(1 2 3,4 5 6)');3
SELECT ST_ZSize('LINESTRING(1 3 4,5 6 7)'::geometry);3
ST_MMin — Returns the M minima of a geometry.
float ST_MMin(geometry geom);
Returns the M minima of a geometry, or null if the geometry lacks M values.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
SELECT ST_MMin('POINT M (1 2 3)');3
ST_MMax — Returns the M maxima of a geometry.
float ST_MMax(geometry geom);
Returns the M maxima of a geometry, or null if the geometry lacks M values.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
SELECT ST_MMax('POINT M (1 2 3)');3
ST_MSize — Returns the M size of a geometry.
float ST_MSize(geometry geom);
Returns the M size of a geometry, computed as ST_MMax(geom) - ST_MMin(geom), or null if the geometry lacks M values.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna metod stöder cirkulära strängar och kurvor.
Availability: 3.7.0
SELECT ST_MSize('LINESTRING M (1 2 3,4 6 8)');5
These functions measure and locate events along linear features. They support the classic linear referencing workflow of expressing positions as fractions or measures along routes and of projecting those measures back into spatial coordinates.
ST_LineInterpolatePoint — Returnerar en punkt som interpolerats längs en linje på en fraktionerad plats.
geometry ST_LineInterpolatePoint(geometry a_linestring, float8 a_fraction);
geography ST_LineInterpolatePoint(geography a_linestring, float8 a_fraction, boolean use_spheroid = true);
Returnerar en punkt som interpolerats längs en linje på en fraktionerad plats. Första argumentet måste vara en LINESTRING. Det andra argumentet är ett flyttal mellan 0 och 1 som representerar den fraktion av linjelängden där punkten ska placeras. Z- och M-värdena interpoleras om de finns.
Se ST_LineLocatePoint för att beräkna linjepositionen närmast en punkt.
![]() | |
Den här funktionen beräknar punkter i 2D och interpolerar sedan värden för Z och M, medan ST_3DLineInterpolatePoint beräknar punkter i 3D och endast interpolerar M-värdet. |
![]() | |
Sedan version 1.1.1 interpolerar denna funktion även M- och Z-värden (om sådana finns), medan tidigare versioner satte dem till 0,0. |
Tillgänglighet: 0.8.2, stöd för Z och M tillkom i 1.1.1
Ändrad: 2.1.0. Fram till 2.0.x hette detta ST_Line_Interpolate_Point.
Denna funktion stöder 3d och kommer inte att tappa z-index.
This example returns the point 20 percent along a line.
SELECT ST_LineInterpolatePoint( 'LINESTRING(25 50,100 125,150 190)', 0.2);
POINT(51.5974135047432 76.5974135047432)
Mittpunkten för en 3D-linje:
SELECT ST_LineInterpolatePoint( 'LINESTRING(1 2 3,4 5 6,6 7 8)', 0.5);
POINT(3.5 4.5 5.5)
Den punkt på en linje som ligger närmast en punkt:
SELECT ST_LineInterpolatePoint(
line.geom,
ST_LineLocatePoint(line.geom, 'POINT(4 3)'))
FROM (SELECT 'LINESTRING(1 2,4 5,6 7)'::geometry As geom) AS line;POINT(3 4)
An interpolated point can be offset to the left or right of a line by using ST_OffsetCurve before interpolation. This is useful for locating an address point beside a street centerline.
WITH street AS (
SELECT 'LINESTRING(0 0, 10 0)'::geometry AS geom,
100 AS from_num,
200 AS to_num
)
SELECT
ST_LineInterpolatePoint(
ST_OffsetCurve(geom, -2),
(160 - from_num)::float8 / (to_num - from_num)
) AS interpolated_offset_point
FROM street;
interpolated_offset_point --------------------------- POINT(6 -2)
ST_3DLineInterpolatePoint — Returnerar en punkt som interpolerats längs en 3D-linje på en fraktionerad plats.
geometry ST_3DLineInterpolatePoint(geometry a_linestring, float8 a_fraction);
Returnerar en punkt som interpolerats längs en 3D-linje på en fraktionerad plats. Första argumentet måste vara en LINESTRING. Det andra argumentet är ett flyttal mellan 0 och 1 som representerar punktens läge som en fraktion av linjens längd. M-värdet interpoleras om det finns.
![]() | |
ST_LineInterpolatePoint beräknar punkter i 2D och interpolerar sedan värdena för Z och M, medan den här funktionen beräknar punkter i 3D och endast interpolerar M-värdet. |
Tillgänglighet: 3.0.0
Denna funktion stöder 3d och kommer inte att tappa z-index.
Returpunkt 20% alång 3D-linje
SELECT ST_3DLineInterpolatePoint( 'LINESTRING(25 50 70,100 125 90,150 190 200)', 0.20);
POINT Z (59.06758929108215 84.06758929108216 79.0846904776219)
ST_LineInterpolatePoints — Returnerar punkter interpolerade längs en linje med ett fraktionerat intervall.
geometry ST_LineInterpolatePoints(geometry a_linestring, float8 a_fraction, boolean repeat);
geography ST_LineInterpolatePoints(geography a_linestring, float8 a_fraction, boolean use_spheroid = true, boolean repeat = true);
Returnerar en eller flera punkter interpolerade längs en linje med ett fraktionerat intervall. Det första argumentet måste vara en LINESTRING. Det andra argumentet är en float8 mellan 0 och 1 som representerar avståndet mellan punkterna som en fraktion av linjens längd. Om det tredje argumentet är false kommer högst en punkt att konstrueras (vilket är likvärdigt med ST_LineInterpolatePoint.)
Om resultatet har noll eller en punkt returneras det som en POINT. Om det har två eller fler punkter returneras det som en MULTIPOINT.
Tillgänglighet: 2.5.0
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder M-koordinater.
This example returns points every 20 percent along a two-dimensional line.
SELECT ST_LineInterpolatePoints( 'LINESTRING(25 50,100 125,150 190)', 0.20);
MULTIPOINT((51.5974135047432 76.5974135047432),(78.1948270094864 103.194827009486),(104.132163186446 130.37181214238),(127.066081593223 160.18590607119),(150 190))
ST_LineLocatePoint — Returnerar den fraktionerade positionen för den punkt på en linje som ligger närmast en punkt.
float8 ST_LineLocatePoint(geometry a_linestring, geometry a_point);
float8 ST_LineLocatePoint(geography a_linestring, geography a_point, boolean use_spheroid = true);
Returnerar en flottör mellan 0 och 1 som representerar platsen för den punkt på en LineString som ligger närmast den angivna Point, som en bråkdel av 2d-linjens längd.
Du kan använda den returnerade platsen för att extrahera en punkt (ST_LineInterpolatePoint) eller en delsträng (ST_LineSubstring).
Detta är användbart för att uppskatta antalet adresser
Tillgänglighet: 1.1.0
Ändrad: 2.1.0. Fram till 2.0.x hette detta ST_Line_Locate_Point.
This example approximates the street number of a house by locating the closest point on a street line. The subquery generates sample house and street data, and ST_DWithin excludes houses that are too far from the street.
SELECT house_loc As as_text_house_loc,
startstreet_num +
CAST( (endstreet_num - startstreet_num)
* ST_LineLocatePoint(street_line, house_loc) As integer) As street_num
FROM
(SELECT 'LINESTRING(1 2,3 4)'::geometry As street_line,
ST_Point(x*1.01, y*1.03) As house_loc, 10 As startstreet_num,
20 As endstreet_num
FROM generate_series(1, 3) x CROSS JOIN generate_series(2, 4) As y)
As foo
WHERE ST_DWithin(street_line, house_loc, 0.2);as_text_house_loc | street_num -------------------+------------ POINT(1.01 2.06) | 10 POINT(2.02 3.09) | 15 POINT(3.03 4.12) | 20
This example finds the closest point on a line to a point or other geometry.
SELECT ST_LineInterpolatePoint(
foo.the_line,
ST_LineLocatePoint(foo.the_line, 'POINT(4 3)'::geometry))
FROM (SELECT 'LINESTRING(1 2,4 5,6 7)'::geometry As the_line) As foo;POINT(3 4)
This example locates the closest segment and point on a LineString.
WITH data AS (
SELECT
'LINESTRING (0 0, 10 10, 20 20, 30 30)'::geometry AS line,
'POINT(15 15.1)'::geometry AS pt
),
segments AS (
SELECT
s.i,
d.pt,
ST_MakeLine(ST_PointN(d.line, s.i), ST_PointN(d.line, s.i + 1)) AS segment
FROM data AS d
CROSS JOIN LATERAL generate_series(1, ST_NumPoints(d.line) - 1) AS s(i)
)
SELECT
i AS segment_number,
round(ST_Distance(segment, pt)::numeric, 3) AS distance,
ST_ClosestPoint(segment, pt) AS closest_point
FROM segments
ORDER BY ST_Distance(segment, pt)
LIMIT 1;segment_number | distance | closest_point
----------------+----------+--------------------
2 | 0.071 | POINT(15.05 15.05)ST_LineSubstring — Returnerar delen av en linje mellan två fraktionerade platser.
geometry ST_LineSubstring(geometry a_linestring, float8 startfraction, float8 endfraction);
geography ST_LineSubstring(geography a_linestring, float8 startfraction, float8 endfraction);
Computes the line which is the section of the input line starting and ending at the given fractional locations. The first argument must be a LINESTRING. The second and third arguments are values in the range [0, 1] representing the start and end locations. For geometry inputs, the fractions are measured in 2D line length. The Z and M values are interpolated for added endpoints if present.
Om startfraktion och slutfraktion har samma värde är detta likvärdigt med ST_LineInterpolatePoint.
![]() | |
Detta fungerar endast med LINESTRINGs. För att använda på sammanhängande MULTILINESTRINGs måste du först sammanfoga dem med ST_LineMerge. |
![]() | |
Sedan release 1.1.1 interpolerar denna funktion M- och Z-värden. Tidigare utgåvor satte Z och M till ospecificerade värden. |
Förbättrad: 3.4.0 - Stöd för geografi infördes.
Ändrad: 2.1.0. Fram till 2.0.x kallades detta ST_Line_Substring.
Tillgänglighet: 1.1.0, stöd för Z och M tillkommer i 1.1.1
Denna funktion stöder 3d och kommer inte att tappa z-index.
Extract the middle third of a LineString, from 0.333 to 0.666.
SELECT ST_LineSubstring( 'LINESTRING (20 180,50 20,90 80,120 40,180 150)', 0.333, 0.666);
LINESTRING (45.17311810399485 45.74337011202746, 50 20, 90 80, 112.97593050157862 49.36542599789519)
Om start- och slutplatserna är desamma blir resultatet en POINT.
SELECT ST_LineSubstring( 'LINESTRING(25 50,100 125,150 190)', 0.333, 0.333);
POINT(69.28469348539744 94.28469348539744)
En fråga för att klippa en LineString i sektioner med längden 100 eller kortare. Den använder generate_series() med en CROSS JOIN LATERAL för att producera motsvarigheten till en FOR-loop.
The final generated step is filtered out when the line length is an exact multiple of the requested section length.
WITH data(id, geom) AS (VALUES
( 'A', 'LINESTRING( 0 0, 200 0)'::geometry ),
( 'B', 'LINESTRING( 0 100, 350 100)'::geometry ),
( 'C', 'LINESTRING( 0 200, 50 200)'::geometry )
)
SELECT id, i,
ST_LineSubstring(geom, startfrac, LEAST( endfrac, 1 )) AS geom
FROM (
SELECT id, geom, ST_Length(geom) len, 100 sublen FROM data
) AS d
CROSS JOIN LATERAL (
SELECT i, (sublen * i) / len AS startfrac,
(sublen * (i+1)) / len AS endfrac
FROM generate_series(0, floor( len / sublen )::integer ) AS t(i)
WHERE (sublen * i) / len <
> 1.0
) AS d2;id | i | geom ----+---+----------------------------- A | 0 | LINESTRING(0 0,100 0) A | 1 | LINESTRING(100 0,200 0) B | 0 | LINESTRING(0 100,100 100) B | 1 | LINESTRING(100 100,200 100) B | 2 | LINESTRING(200 100,300 100) B | 3 | LINESTRING(300 100,350 100) C | 0 | LINESTRING(0 200,50 200)
Split a LineString by points by locating the points along the line, adding the 0 and 1 endpoints, and extracting substrings between adjacent locations.
WITH data AS (
SELECT 'LINESTRING(0 0, 10 0)'::geometry AS line,
'MULTIPOINT((2 0),(5 0),(8 0))'::geometry AS points
),
fractions AS (
SELECT 0.0 AS fraction
UNION ALL
SELECT 1.0
UNION ALL
SELECT ST_LineLocatePoint(line, (dp).geom)
FROM data
CROSS JOIN LATERAL ST_Dump(points) AS dp
),
ordered AS (
SELECT DISTINCT fraction
FROM fractions
),
segments AS (
SELECT fraction AS start_fraction,
lead(fraction) OVER (ORDER BY fraction) AS end_fraction
FROM ordered
)
SELECT row_number() OVER (ORDER BY start_fraction) AS segment_id,
ST_LineSubstring(line, start_fraction, end_fraction) AS geom
FROM data
CROSS JOIN segments
WHERE end_fraction IS NOT NULL
AND start_fraction <
> end_fraction
ORDER BY start_fraction;
segment_id | geom
------------+----------------------
1 | LINESTRING(0 0,2 0)
2 | LINESTRING(2 0,5 0)
3 | LINESTRING(5 0,8 0)
4 | LINESTRING(8 0,10 0)Geografiska implementeringsåtgärder längs en sfäroid, geometri längs en linje
SELECT ST_LineSubstring(
'LINESTRING(-118.2436 34.0522,-71.0570 42.3611)'::geography,
0.333,
0.666) AS geog_sub,
ST_LineSubstring(
'LINESTRING(-118.2436 34.0522,-71.0570 42.3611)'::geometry,
0.333,
0.666) AS geom_sub;For geometry inputs, the fractional locations are based on the 2D length of the line, even when the input has Z values. The resulting Z values are interpolated along the selected 2D location.
WITH data AS (
SELECT 'LINESTRING Z (0 0 0,0 2 5,0 10 10)'::geometry AS geom
)
SELECT ST_Length(geom) AS length_2d,
ST_3DLength(geom) AS length_3d,
ST_LineSubstring(geom, 0, 0.5) AS substring
FROM data;length_2d | length_3d | substring
-----------+------------------+-------------------------------------
10 | 14.819145939191106 | LINESTRING Z (0 0 0,0 2 5,0 5 6.875)ST_LocateAlong — Returnerar den eller de punkter på en geometri som matchar ett mätvärde.
geometry ST_LocateAlong(geometry geom_with_measure, float8 measure, float8 offset = 0);
Returnerar den eller de platser längs en uppmätt geometri som har de angivna mätvärdena. Resultatet är en Point eller MultiPoint. Polygonala indata stöds inte.
Om offset anges, förskjuts resultatet till vänster eller höger om inmatningsraden med det angivna avståndet. En positiv förskjutning blir till vänster och en negativ till höger.
![]() | |
Använd denna funktion endast för linjära geometrier med en M-komponent |
Semantiken specificeras av standarden ISO/IEC 13249-3 SQL/MM Spatial.
Tillgänglighet: 1.1.0 med det gamla namnet ST_Locate_Along_Measure.
Ändrad: 2.0.0 i tidigare versioner kallades detta för ST_Locate_Along_Measure.
Denna funktion stöder M-koordinater.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM IEC 13249-3: 5.1.13
SELECT ST_LocateAlong( 'MULTILINESTRINGM((1 2 3, 3 4 2, 9 4 3),(1 2 3, 5 4 5))'::geometry, 3);
MULTIPOINT M ((1 2 3),(9 4 3),(1 2 3))
ST_LocateBetween — Returnerar de delar av en geometri som matchar ett mätintervall.
geometry ST_LocateBetween(geometry geom, float8 measure_start, float8 measure_end, float8 offset = 0);
Returnerar en geometri (samling) med de delar av den inmatade uppmätta geometrin som matchar det angivna mätområdet (inklusive).
Om offset anges kommer resultatet att förskjutas till vänster eller höger om inmatningsraden med det angivna avståndet. En positiv förskjutning blir till vänster och en negativ till höger.
Att klippa en icke-konvex POLYGON kan ge ogiltig geometri.
Semantiken specificeras av standarden ISO/IEC 13249-3 SQL/MM Spatial.
Tillgänglighet: 1.1.0 med det gamla namnet ST_Locate_Between_Measures.
Ändrad: 2.0.0 - i tidigare versioner hette detta ST_Locate_Between_Measures.
Förbättrad: 3.0.0 - stöd för POLYGON, TIN, TRIANGLE har lagts till.
Denna funktion stöder M-koordinater.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM IEC 13249-3: 5.1
SELECT ST_LocateBetween( 'MULTILINESTRING M ((1 2 3,3 4 2,9 4 3),(1 2 3,5 4 5))'::geometry, 1.5, 3);
GEOMETRYCOLLECTION M (LINESTRING M (1 2 3,3 4 2,9 4 3),POINT M (1 2 3))
Extract the section between measures 2 and 8, offset to the left. Because the clipped line and the offset result share the same coordinate space, this example is intended for a single overlay panel rather than separate side-by-side figures.
SELECT ST_LocateBetween(
ST_AddMeasure(
'LINESTRING (20 180,50 20,100 120,180 20)',
0,
10),
2,
8,
20);MULTILINESTRING((54.49835 104.53427,58.700561 82.122481,82.111456 128.944272,84.248937 132.324934,87.01637 135.21267,90.303073 137.491987,93.977598 139.071724,97.892984 139.888702,101.892639 139.910247,105.816599 139.135495,109.507928 137.595434,112.818995 135.351657,115.617376 132.493901,145.310173 95.377905))
ST_LocateBetweenElevations — Returnerar de delar av en geometri som ligger inom ett höjdintervall (Z).
geometry ST_LocateBetweenElevations(geometry geom, float8 elevation_start, float8 elevation_end);
Returnerar en geometri (samling) med de delar av en geometri som ligger i ett höjdintervall (Z).
Att klippa en icke-konvex POLYGON kan ge ogiltig geometri.
Tillgänglighet: 1.4.0
Förbättrad: 3.0.0 - stöd för POLYGON, TIN, TRIANGLE har lagts till.
Denna funktion stöder 3d och kommer inte att tappa z-index.
SELECT ST_LocateBetweenElevations( 'LINESTRING(1 2 3,4 5 6)'::geometry, 2, 4);
MULTILINESTRING Z ((1 2 3,2 3 4))
SELECT ST_LocateBetweenElevations( 'LINESTRING(1 2 6,4 5 -1,7 8 9)', 6, 9) As ewelev;
GEOMETRYCOLLECTION Z (POINT Z (1 2 6),LINESTRING Z (6.1 7.1 6,7 8 9))
ST_InterpolatePoint — Returnerar det interpolerade måttet för en geometri som ligger närmast en punkt.
float8 ST_InterpolatePoint(geometry linear_geom_with_measure, geometry point);
Returnerar ett interpolerat mätvärde för en linjärt uppmätt geometri på den plats som ligger närmast den angivna punkten.
![]() | |
Använd denna funktion endast för linjära geometrier med en M-komponent |
Tillgänglighet: 2.0.0
Denna funktion stöder 3d och kommer inte att tappa z-index.
SELECT ST_InterpolatePoint( 'LINESTRING M (0 0 0,10 0 20)', 'POINT(5 5)');
10
ST_3DInterpolatePoint — Returns the interpolated measure of a geometry closest to a point in 3D.
float8 ST_3DInterpolatePoint(geometry linear_geom_with_measure, geometry point);
Returns the interpolated measure value of a linear ZM geometry at the location closest to the given point, using 3D (XYZ) distance for the projection. Use this function when the geometry has significant Z variation, such as flight trajectories, where ST_InterpolatePoint would give incorrect results by ignoring the Z dimension.
![]() | |
The line must have both Z and M dimensions. The point should have a Z dimension. |
Availability: 3.7.0
Denna funktion stöder 3d och kommer inte att tappa z-index.
This example interpolates on a line rising diagonally in Z, using a point at the 3D midpoint.
SELECT ST_3DInterpolatePoint( 'LINESTRING ZM (0 0 0 0,10 0 10 20)', 'POINT Z (5 0 5)');
10
This example uses a vertical line with zero XY extent, where 3D projection works but 2D projection does not.
SELECT ST_3DInterpolatePoint( 'LINESTRING ZM (0 0 0 0,0 0 10 100)', 'POINT Z (5 5 5)');
50
ST_AddMeasure — Interpolerar mått längs en linjär geometri.
geometry ST_AddMeasure(geometry geom_mline, float8 measure_start, float8 measure_end);
Returnerar en härledd geometri med mätvärden linjärt interpolerade mellan start- och slutpunkterna. Om geometrin inte har någon måttdimension läggs en till. Om geometrin har en måttdimension skrivs den över med nya värden. Endast LINESTRINGS och MULTILINESTRINGS stöds.
Tillgänglighet: 1.5.0
Denna funktion stöder 3d och kommer inte att tappa z-index.
SELECT ST_AddMeasure( 'LINESTRING(1 0,2 0,4 0)', 1, 4) As ewelev;
LINESTRING M (1 0 1,2 0 2,4 0 4)
SELECT ST_AddMeasure( 'LINESTRING(1 0 4,2 0 4,4 0 4)', 10, 40) As ewelev;
LINESTRING ZM (1 0 4 10,2 0 4 20,4 0 4 40)
SELECT ST_AddMeasure( 'LINESTRINGM(1 0 4, 2 0 4, 4 0 4)', 10, 40) As ewelev;
LINESTRING M (1 0 10,2 0 20,4 0 40)
SELECT ST_AddMeasure( 'MULTILINESTRINGM((1 0 4, 2 0 4, 4 0 4),(1 0 4, 2 0 4, 4 0 4))', 10, 70) As ewelev;
MULTILINESTRING M ((1 0 10,2 0 20,4 0 40),(1 0 40,2 0 50,4 0 70))
Dessa funktioner stöder arbete med banor. En bana är en linjär geometri med ökande mått (M-värde) på varje koordinat. Spatialt-temporala data kan modelleras genom att använda relativa tider (t.ex. epoken) som mätvärden.
ST_IsValidTrajectory — Testar om geometrin är en giltig bana.
boolean ST_IsValidTrajectory(geometry line);
Testar om en geometri kodar för en giltig bana. En giltig bana representeras som en LINESTRING med mått (M-värden). Mätvärdena måste öka från varje toppunkt till nästa.
Giltiga banor förväntas som indata till spatio-temporala funktioner som ST_ClosestPointOfApproach
Tillgänglighet: 2.2.0
Denna funktion stöder 3d och kommer inte att tappa z-index.
This example constructs a valid trajectory.
SELECT ST_IsValidTrajectory(ST_MakeLine(ST_MakePointM(0, 0, 1), ST_MakePointM(0, 1, 2)));
t
This example constructs an invalid trajectory.
SELECT ST_IsValidTrajectory(ST_MakeLine(ST_MakePointM(0, 0, 1), ST_MakePointM(0, 1, 0)));
NOTICE: Measure of vertex 1 (0) not bigger than measure of vertex 0 (1) f
ST_ClosestPointOfApproach — Returnerar ett mått på den närmaste närmandepunkten för två banor.
float8 ST_ClosestPointOfApproach(geometry track1, geometry track2);
Returnerar det minsta mått vid vilket punkter interpolerade längs de givna banorna har det minsta avståndet från varandra.
Ingångarna måste vara giltiga banor som kontrolleras av ST_IsValidTrajectory. Null returneras om banorna inte överlappar varandra i sina M-intervall.
För att få de faktiska punkterna vid det beräknade måttet använder du ST_LocateAlong.
Tillgänglighet: 2.2.0
Denna funktion stöder 3d och kommer inte att tappa z-index.
Return the time in which two objects moving between 10:00 and 11:00 are closest to each other and their distance at that point.
WITH inp AS ( SELECT
ST_AddMeasure('LINESTRING Z (0 0 0,10 0 5)'::geometry,
extract(epoch from timestamp '2015-05-26 10:00' AT TIME ZONE 'UTC'),
extract(epoch from timestamp '2015-05-26 11:00' AT TIME ZONE 'UTC')
) a,
ST_AddMeasure('LINESTRING Z (0 2 10,12 1 2)'::geometry,
extract(epoch from timestamp '2015-05-26 10:00' AT TIME ZONE 'UTC'),
extract(epoch from timestamp '2015-05-26 11:00' AT TIME ZONE 'UTC')
) b
), cpa AS (
SELECT ST_ClosestPointOfApproach(a, b) m FROM inp
), points AS (
SELECT ST_GeometryN(ST_LocateAlong(a, m), 1) pa,
ST_GeometryN(ST_LocateAlong(b, m), 1) pb
FROM inp, cpa
)
SELECT to_timestamp(m) AT TIME ZONE 'UTC' t,
ST_3DDistance(pa, pb) distance,
pa AS pa, pb AS pb
FROM points, cpa;-[ RECORD 1 ]----------------------------- t | 2015-05-26 10:45:31.034483 distance | 1.9652147377620688 pa | POINT ZM (7.59 0 3.79 1432637131.03) pb | POINT ZM (9.1 1.24 3.93 1432637131.03)
ST_DistanceCPA — Returnerar avståndet mellan de två banornas närmaste närmandepunkter.
float8 ST_DistanceCPA(geometry track1, geometry track2);
Returnerar avståndet (i 2D) mellan två banor vid deras närmaste närmandepunkt.
Ingångarna måste vara giltiga banor som kontrolleras av ST_IsValidTrajectory. Null returneras om banorna inte överlappar varandra i sina M-intervall.
Tillgänglighet: 2.2.0
Denna funktion stöder 3d och kommer inte att tappa z-index.
Return the minimum distance of two objects moving between 10:00 and 11:00.
WITH inp AS ( SELECT
ST_AddMeasure('LINESTRING Z (0 0 0,10 0 5)'::geometry,
extract(epoch from timestamp '2015-05-26 10:00' AT TIME ZONE 'UTC'),
extract(epoch from timestamp '2015-05-26 11:00' AT TIME ZONE 'UTC')
) a,
ST_AddMeasure('LINESTRING Z (0 2 10,12 1 2)'::geometry,
extract(epoch from timestamp '2015-05-26 10:00' AT TIME ZONE 'UTC'),
extract(epoch from timestamp '2015-05-26 11:00' AT TIME ZONE 'UTC')
) b
)
SELECT ST_DistanceCPA(a, b) distance FROM inp;1.9652147377620688
ST_CPAWithin — Testar om den närmaste punkten för två banor ligger inom det angivna avståndet.
boolean ST_CPAWithin(geometry track1, geometry track2, float8 dist);
Testar om två rörliga objekt någonsin har varit närmare än det angivna avståndet.
Ingångarna måste vara giltiga banor som kontrolleras av ST_IsValidTrajectory. False returneras om banorna inte överlappar varandra i sina M-områden.
Tillgänglighet: 2.2.0
Denna funktion stöder 3d och kommer inte att tappa z-index.
WITH inp AS ( SELECT
ST_AddMeasure('LINESTRING Z (0 0 0,10 0 5)'::geometry,
extract(epoch from timestamp '2015-05-26 10:00' AT TIME ZONE 'UTC'),
extract(epoch from timestamp '2015-05-26 11:00' AT TIME ZONE 'UTC')
) a,
ST_AddMeasure('LINESTRING Z (0 2 10,12 1 2)'::geometry,
extract(epoch from timestamp '2015-05-26 10:00' AT TIME ZONE 'UTC'),
extract(epoch from timestamp '2015-05-26 11:00' AT TIME ZONE 'UTC')
) b
)
SELECT ST_CPAWithin(a, b, 2), ST_DistanceCPA(a, b) distance FROM inp;st_cpawithin | distance --------------+------------------ t | 1.9652147377620688
Dessa funktioner rapporterar och uppgraderar PostGIS-versioner.
PostGIS_Extensions_Upgrade — Paketerar och uppgraderar PostGIS-tillägg (t.ex. postgis_raster, postgis_topology, postgis_sfcgal) till given eller senaste version.
text PostGIS_Extensions_Upgrade(text target_version=null);
Packages and upgrades PostGIS extensions to given or latest version. Only extensions you have installed in the database will be packaged and upgraded if needed. Reports full PostGIS version and build configuration infos after. This is short-hand for doing multiple CREATE EXTENSION .. FROM unpackaged and ALTER EXTENSION .. UPDATE for each PostGIS extension. Currently only tries to upgrade extensions postgis, postgis_raster, postgis_sfcgal, and postgis_topology.
Tillgänglighet: 2.5.0
Ändrad: 3.4.0 för att lägga till argumentet target_version.
Ändrat: 3.3.0 stöd för uppgraderingar från alla PostGIS-versioner. Fungerar inte på alla system.
Ändrad: 3.0.0 för att packa om lösa tillägg och stödja postgis_raster.
SELECT PostGIS_Extensions_Upgrade();
NOTICE: Packaging extension postgis NOTICE: Packaging extension postgis_raster NOTICE: Packaging extension postgis_sfcgal NOTICE: Extension postgis_topology is not available or not packagable for some reason
PostGIS_Full_Version — Rapporterar fullständig information om PostGIS-version och byggkonfiguration.
text PostGIS_Full_Version();
Rapporterar fullständig information om PostGIS-version och byggkonfiguration. Informerar också om synkronisering mellan bibliotek och skript som föreslår uppgraderingar vid behov.
Förbättrad: 3.4.0 innehåller nu extra PROJ-konfigurationer NETWORK_ENABLED, URL_ENDPOINT och DATABASE_PATH för proj.db-platsen
SELECT PostGIS_Full_Version();
POSTGIS="3.7.0dev 3.7.0alpha1-477-ga9004e778" [EXTENSION] PGSQL="180" GEOS="3.15.0beta1" SFCGAL="2.3.0" PROJ="9.8.1 NETWORK_ENABLED=OFF URL_ENDPOINT=https://cdn.proj.org DATABASE_PATH=/usr/share/proj/proj.db" GDAL="GDAL 3.13.1, released 2026/06/01" LIBXML="2.15.3"
PostGIS_GEOS_Version — Returnerar versionsnumret för GEOS-biblioteket.
text PostGIS_GEOS_Version();
Returnerar versionsnumret för GEOS-biblioteket, eller NULL om GEOS-stöd inte är aktiverat.
SELECT PostGIS_GEOS_Version();
3.12.0dev-CAPI-1.18.0
PostGIS_GEOS_Compiled_Version — Returnerar versionsnumret för GEOS-biblioteket som PostGIS byggdes mot.
text PostGIS_GEOS_Compiled_Version();
Returnerar versionsnumret för GEOS-biblioteket, eller mot vilket PostGIS byggdes.
Tillgänglighet: 3.4.0
SELECT PostGIS_GEOS_Compiled_Version();
3.12.0
PostGIS_Liblwgeom_Version — Returnerar versionsnumret för liblwgeom-biblioteket. Detta bör matcha versionen av PostGIS.
text PostGIS_Liblwgeom_Version();
Returnerar versionsnumret för liblwgeom-biblioteket/
SELECT PostGIS_Liblwgeom_Version();
3.4.0dev 3.3.0rc2-993-g61bdf43a7
PostGIS_LibXML_Version — Returnerar versionsnumret för libxml2-biblioteket.
text PostGIS_LibXML_Version();
Returnerar versionsnumret för LibXML2-biblioteket.
Tillgänglighet: 1,5
SELECT PostGIS_LibXML_Version();
2.9.10
PostGIS_LibJSON_Version — Returnerar versionsnumret för libjson-c-biblioteket.
text PostGIS_LibJSON_Version();
Returnerar versionsnumret för LibJSON-C-biblioteket.
SELECT PostGIS_LibJSON_Version();
0.17
PostGIS_Lib_Build_Date — Returnerar byggdatum för PostGIS-biblioteket.
text PostGIS_Lib_Build_Date();
Returnerar byggdatum för PostGIS-biblioteket.
SELECT PostGIS_Lib_Build_Date();
2023-06-22 03:56:11
PostGIS_Lib_Version — Returnerar versionsnumret för PostGIS-biblioteket.
text PostGIS_Lib_Version();
Returnerar versionsnumret för PostGIS-biblioteket.
SELECT PostGIS_Lib_Version();
3.4.0dev
PostGIS_PROJ_Version — Returnerar versionsnumret för PROJ4-biblioteket.
text PostGIS_PROJ_Version();
Returnerar versionsnumret för PROJ-biblioteket och vissa konfigurationsalternativ för proj.
Förbättrad: 3.4.0 inkluderar nu NETWORK_ENABLED, URL_ENDPOINT och DATABASE_PATH för proj.db-platsen
SELECT PostGIS_PROJ_Version();
7.2.1 NETWORK_ENABLED=OFF URL_ENDPOINT=https://cdn.proj.org USER_WRITABLE_DIRECTORY=/tmp/proj DATABASE_PATH=/usr/share/proj/proj.db
PostGIS_PROJ_Compiled_Version — Returnerar versionsnumret för PROJ-biblioteket som PostGIS byggdes mot.
text PostGIS_PROJ_Compiled_Version();
Returnerar versionsnumret för PROJ-biblioteket, eller mot vilket PostGIS byggdes.
Tillgänglighet: 3.5.0
SELECT PostGIS_PROJ_Compiled_Version();
9.1.1
PostGIS_Wagyu_Version — Returnerar versionsnumret för det interna Wagyu-biblioteket.
text PostGIS_Wagyu_Version();
Returnerar versionsnumret för det interna Wagyu-biblioteket, eller NULL om Wagyu-stöd inte är aktiverat.
SELECT PostGIS_Wagyu_Version();
0.5.0 (Internal)
PostGIS_Scripts_Build_Date — Returnerar byggdatum för PostGIS-skript.
text PostGIS_Scripts_Build_Date();
Returnerar byggdatum för PostGIS-skript.
Tillgänglighet: 1.0.0RC1
SELECT PostGIS_Scripts_Build_Date();
2023-06-22 03:56:11
PostGIS_Scripts_Installed — Returnerar versionen av de PostGIS-skript som är installerade i databasen.
text PostGIS_Scripts_Installed();
Returnerar versionen av de PostGIS-skript som är installerade i databasen.
![]() | |
Om utdata från denna funktion inte stämmer överens med utdata från PostGIS_Scripts_Released har du förmodligen missat att uppgradera en befintlig databas på rätt sätt. Se avsnittet Uppgradering för mer information. |
Tillgänglighet: 0.9.0
SELECT PostGIS_Scripts_Installed();
3.4.0dev 3.3.0rc2-993-g61bdf43a7
PostGIS_Scripts_Released — Returnerar versionsnumret för skriptet postgis.sql som släpptes med det installerade PostGIS-biblioteket.
text PostGIS_Scripts_Released();
Returnerar versionsnumret för skriptet postgis.sql som släpptes med det installerade PostGIS-biblioteket.
![]() | |
Från och med version 1.1.0 returnerar denna funktion samma värde som PostGIS_Lib_Version. Bevaras för bakåtkompatibilitet. |
Tillgänglighet: 0.9.0
SELECT PostGIS_Scripts_Released();
3.4.0dev 3.3.0rc2-993-g61bdf43a7
PostGIS_Version — Returnerar PostGIS versionsnummer och kompileringstidsalternativ.
text PostGIS_Version();
Returnerar PostGIS versionsnummer och kompileringstidsalternativ.
SELECT PostGIS_Version();
3.4 USE_GEOS=1 USE_PROJ=1 USE_STATS=1
I detta avsnitt listas anpassade PostGIS Grand Unified Custom Variables (GUC). Dessa kan ställas in globalt, per databas, per session eller per transaktion. Bäst att ställa in på global nivå eller databasnivå.
För fler exempel på användning, se SQL SET och SQL ALTER SYSTEM
postgis.gdal_datapath — Ett konfigurationsalternativ för att tilldela värdet för GDAL:s GDAL_DATA-alternativ. Om den inte är inställd används den miljöinställda variabeln GDAL_DATA.
En PostgreSQL GUC-variabel för att ställa in värdet på GDAL: s GDAL_DATA-alternativ. Värdet postgis.gdal_datapath bör vara den fullständiga fysiska sökvägen till GDAL:s datafiler.
Detta konfigurationsalternativ är mest användbart för Windows-plattformar där GDAL:s datafilsökväg inte är hårdkodad. Detta alternativ bör också ställas in när GDAL:s datafiler inte finns i GDAL:s förväntade sökväg.
![]() | |
Detta alternativ kan ställas in i PostgreSQL: s konfigurationsfil postgresql.conf. Det kan också ställas in via anslutning eller transaktion. |
Tillgänglighet: 2.2.0
![]() | |
Ytterligare information om GDAL_DATA finns på GDAL:s konfigurationsalternativ. |
Ställ in och återställ postgis.gdal_datapath
SET postgis.gdal_datapath TO '/usr/local/share/gdal.hidden';
SET postgis.gdal_datapath TO default;
Inställning av fönster för en viss databas
ALTER DATABASE gisdb SET postgis.gdal_datapath = 'C:/Program Files/PostgreSQL/9.3/gdal-data';
postgis.gdal_enabled_drivers — Ett konfigurationsalternativ för att ställa in de aktiverade GDAL-drivrutinerna i PostGIS-miljön. Påverkar GDAL-konfigurationsvariabeln GDAL_SKIP.
Ett konfigurationsalternativ för att ställa in de aktiverade GDAL-drivrutinerna i PostGIS-miljön. Påverkar GDAL-konfigurationsvariabeln GDAL_SKIP. Det här alternativet kan ställas in i PostgreSQL: s konfigurationsfil: postgresql.conf. Det kan också ställas in via anslutning eller transaktion.
Det initiala värdet för postgis.gdal_enabled_drivers kan också ställas in genom att skicka miljövariabeln POSTGIS_GDAL_ENABLED_DRIVERS med listan över aktiverade drivrutiner till processen som startar PostgreSQL.
Aktiverade GDAL specificerade drivrutiner kan specificeras med drivrutinens kortnamn eller kod. Kortnamn eller koder för drivrutiner finns på GDAL Raster Formats. Flera drivrutiner kan specificeras genom att lägga till ett mellanslag mellan varje drivrutin.
![]() | |
Det finns tre specialkoder tillgängliga för
När |
![]() | |
I standardinstallationen av PostGIS är |
![]() | |
Ytterligare information om GDAL_SKIP finns på GDAL:s konfigurationsalternativ. |
Tillgänglighet: 2.2.0
Set and reset postgis.gdal_enabled_drivers for the current session.
SET postgis.gdal_enabled_drivers = 'ENABLE_ALL';
SET postgis.gdal_enabled_drivers = default;
Set specific drivers for all new connections to a database.
ALTER DATABASE mygisdb SET postgis.gdal_enabled_drivers TO 'GTiff PNG JPEG';
Set the default for the whole database cluster to enable all drivers. This requires superuser access. Also note that database, session, and user settings override this.
This example writes the setting to postgres.auto.conf.
ALTER SYSTEM SET postgis.gdal_enabled_drivers TO 'ENABLE_ALL';
Reload the PostgreSQL configuration so the changed setting is applied.
SELECT pg_reload_conf();
postgis.enable_outdb_rasters — Ett booleskt konfigurationsalternativ för att aktivera åtkomst till out-db-rasterband.
Ett boolskt konfigurationsalternativ för att aktivera åtkomst till out-db rasterband. Detta alternativ kan ställas in i PostgreSQL: s konfigurationsfil: postgresql.conf. Det kan också ställas in via anslutning eller transaktion.
Det initiala värdet för postgis.enable_outdb_rasters kan också ställas in genom att skicka miljövariabeln POSTGIS_ENABLE_OUTDB_RASTERS med ett icke-nollvärde till processen som startar PostgreSQL.
![]() | |
Även om |
![]() | |
I standardinstallationen av PostGIS är |
Tillgänglighet: 2.2.0
Set and reset postgis.enable_outdb_rasters for the current session.
SET postgis.enable_outdb_rasters TO True;
SET postgis.enable_outdb_rasters = default;
SET postgis.enable_outdb_rasters = True;
SET postgis.enable_outdb_rasters = False;
Set the default for all new connections to a database.
ALTER DATABASE gisdb SET postgis.enable_outdb_rasters = true;
Set the default for the whole database cluster. This requires superuser access. Also note that database, session, and user settings override this.
This example writes the setting to postgres.auto.conf.
ALTER SYSTEM SET postgis.enable_outdb_rasters = true;
Reload the PostgreSQL configuration so the changed setting is applied.
SELECT pg_reload_conf();
postgis.gdal_vsi_options — En strängkonfiguration för att ställa in alternativ som används när du arbetar med ett out-db-raster.
En strängkonfiguration för att ställa in alternativ som används när du arbetar med en out-db-raster. Konfigurationsalternativ styr saker som hur mycket utrymme GDAL tilldelar lokal datacache, om översikter ska läsas och vilka åtkomstnycklar som ska användas för fjärranslutna out-db-datakällor.
Tillgänglighet: 3.2.0
Ställ in postgis.gdal_vsi_options för aktuell session:
SET postgis.gdal_vsi_options = 'AWS_ACCESS_KEY_ID=xxxxxxxxxxxxxxx AWS_SECRET_ACCESS_KEY=yyyyyyyyyyyyyyyyyyyyyyyyyy';
Ställ in postgis.gdal_vsi_options bara för den aktuella transaktionen med hjälp av nyckelordet LOCAL:
SET LOCAL postgis.gdal_vsi_options = 'AWS_ACCESS_KEY_ID=xxxxxxxxxxxxxxx AWS_SECRET_ACCESS_KEY=yyyyyyyyyyyyyyyyyyyyyyyyyy';
postgis.gdal_cpl_debug — En boolesk konfiguration för att aktivera eller inaktivera loggning av GDAL-felsökningsmeddelanden.
Som standard skrivs GDAL-loggning ut till stderr, och felsökningsmeddelanden på lägre nivå skrivs inte ut alls. Att göra denna GUC till sant kommer att orsaka att GDAL-loggning skickas till PostgreSQL-loggningsströmmen, så att du kan se mer eller mindre av det genom att ändra client_min_message PostgreSQL GUC.
Tillgänglighet: 3.6.0
Dessa funktioner är verktyg för felsökning och reparation av geometridata. De behövs bara om geometridata är korrumperade på något sätt, vilket aldrig ska hända under normala omständigheter.
PostGIS_AddBBox — Lägg till en begränsningsbox till geometrin.
geometry PostGIS_AddBBox(geometry geomA);
Lägg till en begränsningsbox i geometrin. Detta skulle göra frågor baserade på bounding box snabbare, men kommer att öka geometrins storlek.
![]() | |
Begränsningsrutor läggs automatiskt till geometrier så i allmänhet behövs inte detta om inte den genererade begränsningsrutan på något sätt blir skadad eller om du har en gammal installation som saknar begränsningsrutor. Då måste du ta bort de gamla och lägga till dem igen. |
Denna metod stöder cirkulära strängar och kurvor.
UPDATE sometable SET geom = PostGIS_AddBBox(geom) WHERE PostGIS_HasBBox(geom) = false;
PostGIS_DropBBox — Ta bort begränsningsboxens cache från geometrin.
geometry PostGIS_DropBBox(geometry geomA);
Ta bort bounding box-cachen från geometrin. Detta minskar geometrins storlek, men gör frågor baserade på bounding box långsammare. Det används också för att släppa en korrupt bounding box. Ett tecken på en korrupt cachelagrad bounding box är när ST_Intersects och andra relationsfrågor utelämnar geometrier som rätteligen borde returnera true.
![]() | |
Begränsningsrutor läggs automatiskt till geometrier och förbättrar hastigheten på frågor så i allmänhet behövs detta inte om inte den genererade begränsningsrutan på något sätt blir skadad eller om du har en gammal installation som saknar begränsningsrutor. Då måste du ta bort den gamla och lägga till den på nytt. Denna typ av korruption har observerats i 8.3-8.3.6-serien varigenom cachade bboxar inte alltid omräknades när en geometri ändrades och uppgradering till en nyare version utan en omladdning av dumpning kommer inte att korrigera redan korrupta boxar. Så man kan korrigera manuellt med hjälp av nedan och lägga till bboxen igen eller göra en dump-omladdning. |
Denna metod stöder cirkulära strängar och kurvor.
This example drops cached bounding boxes where the stored box is wrong. Applying Box2D to ST_AsBinary forces a fresh box calculation, while Box2D on the table geometry reads the cached box.
UPDATE sometable SET geom = PostGIS_DropBBox(geom) WHERE Not (Box2D(ST_AsBinary(geom)) = Box2D(geom));
UPDATE ...
After dropping corrupt cached boxes, re-add them where needed.
UPDATE sometable SET geom = PostGIS_AddBBox(geom) WHERE Not PostGIS_HasBBOX(geom);
UPDATE ...
PostGIS_HasBBox — Returnerar TRUE om bboxen för denna geometri är cachad, FALSE annars.
boolean PostGIS_HasBBox(geometry geomA);
Returnerar TRUE om bboxen för denna geometri är cachelagrad, FALSE annars. Använd PostGIS_AddBBox och PostGIS_DropBBox för att styra cachelagring.
Denna metod stöder cirkulära strängar och kurvor.
SELECT geom FROM sometable WHERE PostGIS_HasBBox(geom) = false;
SFCGAL är ett C++-bibliotek runt CGAL som tillhandahåller avancerade 2D- och 3D-spatiala funktioner. För robusthetens skull har geometrikoordinaterna en exakt representation av rationella tal.
Installationsanvisningar för biblioteket finns på SFCGAL:s hemsida(http://www.sfcgal.org). För att aktivera funktionerna använd create extension postgis_sfcgal.
I det här avsnittet listas funktioner för att fastställa vilken version av SFCGAL och biblioteksberoenden du kör.
postgis_sfcgal_version — Returnerar den version av SFCGAL som används
text postgis_sfcgal_version(void);
Returnerar den version av SFCGAL som används
Tillgänglighet: 2.1.0
Denna metod behöver SFCGAL-backend.
postgis_sfcgal_full_version — Returnerar den fullständiga versionen av SFCGAL som används, inklusive CGAL- och Boost-versioner
text postgis_sfcgal_full_version(void);
Returnerar den fullständiga versionen av SFCGAL som används, inklusive CGAL- och Boost-versioner
Tillgänglighet: 3.3.0
Denna metod behöver SFCGAL-backend.
Dessa funktioner ger åtkomst till eller anger egenskaper för geometrier. Geometrier som främst stöds av dessa funktioner är TINS och Polyhedral Surfaces.
CG_ForceLHR — Tvinga fram LHR-orientering
geometry CG_ForceLHR(geometry geom);
Returns an equivalent geometry whose polygonal components follow the left-hand rule: exterior rings are counter-clockwise and interior rings are clockwise. Rings are reversed as needed; coordinates and dimensionality are preserved. The input must be valid.
Tillgänglighet: 3.5.0
Denna metod behöver SFCGAL-backend.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
Reorient a polygon and its hole to the left-hand rule.
WITH data AS (
SELECT 'POLYGON((0 0,0 4,4 4,4 0,0 0),
(1 1,3 1,3 3,1 3,1 1))'::geometry AS geom
)
SELECT geom AS input_polygon,
CG_ForceLHR(geom) AS lhr_polygon,
ST_IsPolygonCCW(geom) AS input_is_lhr,
ST_IsPolygonCCW(CG_ForceLHR(geom)) AS output_is_lhr
FROM data;POLYGON((0 0,0 4,4 4,4 0,0 0),(1 1,3 1,3 3,1 3,1 1)) | POLYGON((0 0,4 0,4 4,0 4,0 0),(1 1,1 3,3 3,3 1,1 1)) | f | t
CG_IsPlanar — Kontrollera om en yta är plan eller inte
boolean CG_IsPlanar(geometry geom);
Tests whether the input geometry lies in a single plane in 3D.
Tillgänglighet: 3.5.0
Denna metod behöver SFCGAL-backend.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
CG_IsSolid — Testar om geometrin är en solid. Ingen validitetskontroll utförs.
boolean CG_IsSolid(geometry geom1);
Returns true when the input carries the solid flag, such as a geometry produced by CG_MakeSolid. A closed PolyhedralSurface remains a surface until it is explicitly converted. This tests the representation, not shell closure or validity; no validity check is performed.
Tillgänglighet: 3.5.0
Denna metod behöver SFCGAL-backend.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
Compare the same closed shell before and after converting it to a solid.
WITH data AS (
SELECT 'POLYHEDRALSURFACE Z (
((0 0 0,0 0 1,0 1 1,0 1 0,0 0 0)),
((0 0 0,0 1 0,1 1 0,1 0 0,0 0 0)),
((0 0 0,1 0 0,1 0 1,0 0 1,0 0 0)),
((1 1 0,1 1 1,1 0 1,1 0 0,1 1 0)),
((0 1 0,0 1 1,1 1 1,1 1 0,0 1 0)),
((0 0 1,1 0 1,1 1 1,0 1 1,0 0 1))
)'::geometry AS geom
)
SELECT CG_IsSolid(geom) AS shell_is_solid,
CG_IsSolid(CG_MakeSolid(geom)) AS solid_is_solid
FROM data;f | t
CG_MakeSolid — Casta geometrin till en solid. Ingen kontroll utförs. För att få en giltig solid måste indatageometrin vara en sluten polyedrisk yta eller en sluten TIN.
geometry CG_MakeSolid(geometry geom1);
Marks a PolyhedralSurface or TIN as a solid. The input is expected to describe a closed shell; the function sets the solid representation and does not validate the shell.
Tillgänglighet: 3.5.0
Denna metod behöver SFCGAL-backend.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
CG_Orientation — Bestäm ytans orientering
integer CG_Orientation(geometry geom);
Funktionen gäller endast för polygoner. Den returnerar -1 om polygonen är orienterad moturs och 1 om polygonen är orienterad medurs.
Tillgänglighet: 3.5.0
Denna metod behöver SFCGAL-backend.
Denna funktion stöder 3d och kommer inte att tappa z-index.
CG_Area — Beräknar arean av en geometri
double precision CG_Area( geometry geom );
Beräknar arean av en geometri.
Utförs av SFCGAL-modulen
![]() | |
OBS: Denna funktion returnerar ett värde med dubbel precision som representerar området. |
Tillgänglighet: 3.5.0
Denna metod behöver SFCGAL-backend.
SELECT CG_Area('Polygon ((0 0,0 5,5 5,5 0,0 0),(1 1,2 1,2 2,1 2,1 1),(3 3,4 3,4 4,3 4,3 3))');23
CG_3DArea — Beräknar area för 3D-ytgeometrier. Returnerar 0 för solider.
floatCG_3DArea(geometry geom1);
Tillgänglighet: 3.5.0
Denna metod behöver SFCGAL-backend.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM IEC 13249-3: 8.1, 10.5
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
Obs: Som standard är en PolyhedralSurface som byggts från WKT en ytgeometri, inte en solid. Den har därför en ytarea. När den har konverterats till en solid har den ingen area.
SELECT CG_3DArea(geom) As cube_surface_area, CG_3DArea(CG_MakeSolid(geom)) As solid_surface_area FROM (SELECT 'POLYHEDRALSURFACE( ((0 0 0,0 0 1,0 1 1,0 1 0,0 0 0)), ((0 0 0,0 1 0,1 1 0,1 0 0,0 0 0)), ((0 0 0,1 0 0,1 0 1,0 0 1,0 0 0)), ((1 1 0,1 1 1,1 0 1,1 0 0,1 1 0)), ((0 1 0,0 1 1,1 1 1,1 1 0,0 1 0)), ((0 0 1,1 0 1,1 1 1,0 1 1,0 0 1)) )'::geometry) As f(geom);
cube_surface_area │ solid_surface_area ──────────────────┼──────────────────── 6 │ 0
CG_Volume — Computes the volume of a 3D geometry. Closed surfaces can have non-zero volume.
float CG_Volume(geometry geom1);
Tillgänglighet: 3.5.0
Denna metod behöver SFCGAL-backend.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
Denna metod implementerar SQL/MM-specifikationen. SQL-MM IEC 13249-3: 9.1 (samma som CG_3DVolume)
Closed surface geometries can have non-zero volume. Use CG_MakeSolid when the geometry value itself must carry the solid flag.
A closed polyhedral surface has volume. CG_MakeSolid makes the solid representation explicit.
SELECT CG_Volume(geom) As cube_surface_vol, CG_Volume(CG_MakeSolid(geom)) As solid_surface_vol FROM (SELECT 'POLYHEDRALSURFACE( ((0 0 0,0 0 1,0 1 1,0 1 0,0 0 0)), ((0 0 0,0 1 0,1 1 0,1 0 0,0 0 0)), ((0 0 0,1 0 0,1 0 1,0 0 1,0 0 0)), ((1 1 0,1 1 1,1 0 1,1 0 0,1 1 0)), ((0 1 0,0 1 1,1 1 1,1 1 0,0 1 0)), ((0 0 1,1 0 1,1 1 1,0 1 1,0 0 1)) )'::geometry) As f(geom);
cube_surface_vol │ solid_surface_vol ─────────────────┼────────────────── 1 │ 1
CG_Intersection — Beräknar skärningspunkten mellan två geometrier
geometry CG_Intersection( geometry geomA , geometry geomB );
Beräknar skärningspunkten mellan två geometrier.
Utförs av SFCGAL-modulen
![]() | |
OBS: Denna funktion returnerar en geometri som representerar korsningen. |
Tillgänglighet: 3.5.0
Denna metod behöver SFCGAL-backend.
SELECT CG_Intersection('LINESTRING(0 0,5 5)', 'LINESTRING(5 0,0 5)');POINT(2.5 2.5)
CG_Intersects — Testar om två geometrier skär varandra (de har minst en gemensam punkt)
boolean CG_Intersects( geometry geomA , geometry geomB );
Returnerar true om två geometrier korsar varandra. Geometrier korsar varandra om de har någon gemensam punkt.
Utförs av SFCGAL-modulen
![]() | |
OBS: detta är den "tillåtna" versionen som returnerar ett boolean, inte ett heltal. |
Tillgänglighet: 3.5.0
Denna metod behöver SFCGAL-backend.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
SELECT CG_Intersects('POINT(0 0)'::geometry, 'LINESTRING ( 2 0,0 2 )'::geometry);f
SELECT CG_Intersects('POINT(0 0)'::geometry, 'LINESTRING ( 0 0,0 2 )'::geometry);t
CG_3DIntersects — Testar om två 3D-geometrier korsar varandra
boolean CG_3DIntersects( geometry geomA , geometry geomB );
Testar om två 3D-geometrier skär varandra. 3D-geometrier skär varandra om de har någon gemensam punkt i det tredimensionella rummet.
Utförs av SFCGAL-modulen
![]() | |
OBS: detta är den "tillåtna" versionen som returnerar ett boolean, inte ett heltal. |
Tillgänglighet: 3.5.0
Denna metod behöver SFCGAL-backend.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
SELECT CG_3DIntersects('POINT(1.2 0.1 0)', 'POLYHEDRALSURFACE(((0 0 0,0.5 0.5 0,1 0 0,1 1 0,0 1 0,0 0 0)),((1 0 0,2 0 0,2 1 0,1 1 0,1 0 0),(1.2 0.2 0,1.2 0.8 0,1.8 0.8 0,1.8 0.2 0,1.2 0.2 0)))');t
CG_Difference — Beräknar den geometriska skillnaden mellan två geometrier
geometry CG_Difference( geometry geomA , geometry geomB );
Beräknar den geometriska skillnaden mellan två geometrier. Den resulterande geometrin är en uppsättning punkter som finns i geomA men inte i geomB.
Utförs av SFCGAL-modulen
![]() | |
OBS: denna funktion returnerar en geometri. |
Tillgänglighet: 3.5.0
Denna metod behöver SFCGAL-backend.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
SELECT CG_Difference('POLYGON((0 0,0 1,1 1,1 0,0 0))'::geometry, 'LINESTRING(0 0,2 2)'::geometry);POLYGON((0 0,1 0,1 1,0 1,0 0))
CG_3DDifference — Utföra 3D-differens
geometry CG_3DDifference(geometry geom1, geometry geom2);
Returnerar den del av geom1 som inte är en del av geom2.
Tillgänglighet: 3.5.0
Denna metod behöver SFCGAL-backend.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM IEC 13249-3: 5.1
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
Subtract a smaller tetrahedral solid and render the two inputs and the actual remaining solid separately.
WITH data AS (
SELECT CG_MakeSolid('POLYHEDRALSURFACE Z (
((0 0 0,0 4 0,4 0 0,0 0 0)),
((0 0 0,4 0 0,0 0 4,0 0 0)),
((0 0 0,0 0 4,0 4 0,0 0 0)),
((4 0 0,0 4 0,0 0 4,4 0 0))
)'::geometry) AS outer_solid
), solids AS (
SELECT outer_solid,
ST_Scale(outer_solid, 0.5, 0.5, 0.5) AS inner_solid
FROM data
)
SELECT outer_solid AS input_outer,
inner_solid AS input_inner,
CG_3DDifference(outer_solid, inner_solid) AS difference
FROM solids;POLYHEDRALSURFACE Z (((0 0 0,0 4 0,4 0 0,0 0 0)),((0 0 0,4 0 0,0 0 4,0 0 0)),((0 0 0,0 0 4,0 4 0,0 0 0)),((4 0 0,0 4 0,0 0 4,4 0 0))) | POLYHEDRALSURFACE Z (((0 0 0,0 2 0,2 0 0,0 0 0)),((0 0 0,2 0 0,0 0 2,0 0 0)),((0 0 0,0 0 2,0 2 0,0 0 0)),((2 0 0,0 2 0,0 0 2,2 0 0))) | POLYHEDRALSURFACE Z (((0 2 0,4 0 0,2 0 0,0 2 0)),((0 0 2,2 0 0,0 0 4,0 0 2)),((0 0 2,0 4 0,0 2 0,0 0 2)),((4 0 0,0 4 0,0 0 4,4 0 0)),((4 0 0,0 2 0,0 4 0,4 0 0)),((2 0 0,4 0 0,0 0 4,2 0 0)),((0 4 0,0 0 2,0 0 4,0 4 0)),((0 0 2,0 2 0,2 0 0,0 0 2)))
CG_Distance — Beräknar det minsta avståndet mellan två geometrier
double precision CG_Distance( geometry geomA , geometry geomB );
Beräknar det minsta avståndet mellan två geometrier.
Utförs av SFCGAL-modulen
![]() | |
OBS: Denna funktion returnerar ett värde med dubbel precision som representerar avståndet. |
Tillgänglighet: 3.5.0
Denna metod behöver SFCGAL-backend.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
SELECT CG_Distance('LINESTRING(0.0 0.0,-1.0 -1.0)', 'LINESTRING(3.0 4.0,4.0 5.0)');5
CG_3DDistance — Beräknar det minsta 3D-avståndet mellan två geometrier
double precision CG_3DDistance( geometry geomA , geometry geomB );
Beräknar det minsta 3D-avståndet mellan två geometrier.
Utförs av SFCGAL-modulen
![]() | |
OBS: Denna funktion returnerar ett värde med dubbel precision som representerar 3D-avståndet. |
Tillgänglighet: 3.5.0
Denna metod behöver SFCGAL-backend.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
SELECT CG_3DDistance('LINESTRING(-1.0 0.0 2.0,1.0 0.0 3.0)', 'TRIANGLE((-4.0 0.0 1.0,4.0 0.0 1.0,0.0 4.0 1.0,-4.0 0.0 1.0))');1
CG_3DConvexHull — Beräknar den konvexa 3D-skålen för en geometri.
geometry CG_3DConvexHull(geometry geom1);
Computes the smallest convex three-dimensional geometry that contains the input. Unlike ST_ConvexHull, this function uses Z coordinates when constructing the hull.
Tillgänglighet: 3.5.0
Denna metod behöver SFCGAL-backend.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
Compute the 3D convex hull of a 3D LineString.
WITH data AS ( SELECT 'LINESTRING Z(0 0 5,1 5 3,5 7 6,9 5 3,5 7 5,6 3 5)'::geometry AS source_line ) SELECT CG_3DConvexHull(source_line) AS convex_hull FROM data;
POLYHEDRALSURFACE Z (((1 5 3,9 5 3,0 0 5,1 5 3)),((1 5 3,0 0 5,5 7 6,1 5 3)),((5 7 6,5 7 5,1 5 3,5 7 6)),((0 0 5,6 3 5,5 7 6,0 0 5)),((6 3 5,9 5 3,5 7 6,6 3 5)),((0 0 5,9 5 3,6 3 5,0 0 5)),((9 5 3,5 7 5,5 7 6,9 5 3)),((1 5 3,5 7 5,9 5 3,1 5 3)))
Compare the extruded source geometry with its 3D convex hull.
WITH footprints(label, geom, height) AS (VALUES
('C', 'POLYGON((0 0,0 8,5 8,5 6,2 6,2 2,5 2,5 0,0 0))'::geometry, 3),
('H', 'POLYGON((7 0,9 0,9 3,12 3,12 0,14 0,14 8,12 8,12 5,9 5,9 8,7 8,7 0))'::geometry, 7)
), parts AS (
SELECT label, CG_Extrude(geom, 0, 0, height) AS geom
FROM footprints
), shapes AS (
SELECT ST_Collect(geom ORDER BY label) AS source_geometry
FROM parts
)
SELECT
source_geometry AS input_source_geometry,
CG_3DConvexHull(source_geometry) AS convex_hull
FROM shapes;CG_3DIntersection — Utför 3D-intersektion
geometry CG_3DIntersection(geometry geom1, geometry geom2);
Returnerar en geometri som är den delade delen mellan geom1 och geom2.
Tillgänglighet: 3.5.0
Denna metod behöver SFCGAL-backend.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM IEC 13249-3: 5.1
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
3D linestrings and polygons can intersect in a 3D segment.
WITH data AS (
SELECT 'LINESTRING Z (2 2 6,1.5 1.5 7,1 1 8,0.5 0.5 8,0 0 10)'::geometry AS input_linestring,
'POLYGON Z ((0 0 8,0 1 8,1 1 8,1 0 8,0 0 8))'::geometry AS input_polygon
)
SELECT input_linestring AS input_linestring,
input_polygon AS input_polygon,
CG_3DIntersection(input_linestring, input_polygon) AS intersection
FROM data;LINESTRING Z (2 2 6,1.5 1.5 7,1 1 8,0.5 0.5 8,0 0 10) | POLYGON Z ((0 0 8,0 1 8,1 1 8,1 0 8,0 0 8)) | LINESTRING Z (1 1 8,0.5 0.5 8)
Intersect a cube shell with a vertical polygon.
WITH data AS (
SELECT 'POLYHEDRALSURFACE Z(
((0 0 0,0 0 1,0 1 1,0 1 0,0 0 0)),
((0 0 0,0 1 0,1 1 0,1 0 0,0 0 0)),
((0 0 0,1 0 0,1 0 1,0 0 1,0 0 0)),
((1 1 0,1 1 1,1 0 1,1 0 0,1 1 0)),
((0 1 0,0 1 1,1 1 1,1 1 0,0 1 0)),
((0 0 1,1 0 1,1 1 1,0 1 1,0 0 1))
)'::geometry AS input_cube,
'POLYGON Z ((0 0 0,0 0 0.5,0 0.5 0.5,0 0.5 0,0 0 0))'::geometry AS input_polygon
)
SELECT input_cube AS input_cube,
input_polygon AS input_polygon,
CG_3DIntersection(input_cube, input_polygon) AS intersection
FROM data;POLYHEDRALSURFACE Z (((0 0 0,0 0 1,0 1 1,0 1 0,0 0 0)),((0 0 0,0 1 0,1 1 0,1 0 0,0 0 0)),((0 0 0,1 0 0,1 0 1,0 0 1,0 0 0)),((1 1 0,1 1 1,1 0 1,1 0 0,1 1 0)),((0 1 0,0 1 1,1 1 1,1 1 0,0 1 0)),((0 0 1,1 0 1,1 1 1,0 1 1,0 0 1))) | POLYGON Z ((0 0 0,0 0 0.5,0 0.5 0.5,0 0.5 0,0 0 0)) | TIN Z (((0 0 0,0 0 0.5,0 0.5 0.5,0 0 0)),((0 0.5 0,0 0 0,0 0.5 0.5,0 0.5 0)))
A smaller solid contained by a larger solid remains volumetric after intersection.
WITH data AS (
SELECT CG_MakeSolid('POLYHEDRALSURFACE Z (
((0 0 0,0 4 0,4 0 0,0 0 0)),
((0 0 0,4 0 0,0 0 4,0 0 0)),
((0 0 0,0 0 4,0 4 0,0 0 0)),
((4 0 0,0 4 0,0 0 4,4 0 0))
)'::geometry) AS outer_solid
), solids AS (
SELECT outer_solid,
ST_Scale(outer_solid, 0.5, 0.5, 0.5) AS inner_solid
FROM data
)
SELECT outer_solid AS input_outer,
inner_solid AS input_inner,
CG_3DIntersection(outer_solid, inner_solid) AS intersection
FROM solids;POLYHEDRALSURFACE Z (((0 0 0,0 4 0,4 0 0,0 0 0)),((0 0 0,4 0 0,0 0 4,0 0 0)),((0 0 0,0 0 4,0 4 0,0 0 0)),((4 0 0,0 4 0,0 0 4,4 0 0))) | POLYHEDRALSURFACE Z (((0 0 0,0 2 0,2 0 0,0 0 0)),((0 0 0,2 0 0,0 0 2,0 0 0)),((0 0 0,0 0 2,0 2 0,0 0 0)),((2 0 0,0 2 0,0 0 2,2 0 0))) | POLYHEDRALSURFACE Z (((0 0 0,0 2 0,2 0 0,0 0 0)),((0 0 0,0 0 2,0 2 0,0 0 0)),((2 0 0,0 0 2,0 0 0,2 0 0)),((2 0 0,0 2 0,0 0 2,2 0 0)))
CG_Union — Beräknar föreningen av två geometrier
geometry CG_Union( geometry geomA , geometry geomB );
Beräknar föreningen av två geometrier.
Utförs av SFCGAL-modulen
![]() | |
OBS: Denna funktion returnerar en geometri som representerar unionen. |
Tillgänglighet: 3.5.0
Denna metod behöver SFCGAL-backend.
SELECT CG_Union('POINT(.5 0)', 'LINESTRING(-1 0,1 0)');LINESTRING(-1 0,0.5 0,1 0)
CG_3DUnion — Utför 3D-union med hjälp av postgis_sfcgal.
geometry CG_3DUnion(geometry geom1, geometry geom2);
geometry CG_3DUnion(geometry set g1field);
Tillgänglighet: 3.5.0
Denna metod behöver SFCGAL-backend.
Denna metod implementerar SQL/MM-specifikationen. SQL-MM IEC 13249-3: 5.1
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
Aggregerad variant: returnerar en geometri som är 3D-unionen av en raduppsättning geometrier. CG_3DUnion () -funktionen är en "aggregerad" funktion i terminologin för PostgreSQL. Det betyder att den fungerar på rader med data, på samma sätt som SUM () och AVG () -funktionerna gör och som de flesta aggregat ignorerar den också NULL-geometrier.
Union two overlapping tetrahedral solids.
WITH solids AS (
SELECT CG_MakeSolid('POLYHEDRALSURFACE Z (
((0 0 0,4 0 0,0 4 0,0 0 0)),
((0 0 0,0 0 4,4 0 0,0 0 0)),
((0 0 0,0 4 0,0 0 4,0 0 0)),
((4 0 0,0 0 4,0 4 0,4 0 0)))'::geometry) AS geom1,
CG_MakeSolid('POLYHEDRALSURFACE Z (
((2 0 0,6 0 0,2 4 0,2 0 0)),
((2 0 0,2 0 4,6 0 0,2 0 0)),
((2 0 0,2 4 0,2 0 4,2 0 0)),
((6 0 0,2 0 4,2 4 0,6 0 0)))'::geometry) AS geom2
)
SELECT CG_3DUnion(geom1, geom2) AS union_result
FROM solids;POLYHEDRALSURFACE Z (((2 0 0,0 0 0,2 2 0,2 0 0)),((2 0 2,0 0 0,2 0 0,2 0 2)),((0 0 4,0 4 0,0 0 0,0 0 4)),((2 0 2,0 4 0,0 0 4,2 0 2)),((0 4 0,2 2 0,0 0 0,0 4 0)),((2 2 0,0 4 0,2 0 2,2 2 0)),((0 0 0,2 0 2,0 0 4,0 0 0)),((4 0 0,2 0 0,2 2 0,4 0 0)),((4 0 0,2 0 2,2 0 0,4 0 0)),((4 0 0,2 2 0,6 0 0,4 0 0)),((2 0 2,4 0 0,2 0 4,2 0 2)),((2 0 2,2 4 0,2 2 0,2 0 2)),((2 4 0,2 0 4,6 0 0,2 4 0)),((2 2 0,2 4 0,6 0 0,2 2 0)),((2 4 0,2 0 2,2 0 4,2 4 0)),((4 0 0,6 0 0,2 0 4,4 0 0)))
CG_AlphaShape — Beräknar en Alpha-form som omsluter en geometri
geometry CG_AlphaShape(geometry geom, float alpha, boolean allow_holes = false);
Beräknar Alpha-Shape för punkterna i en geometri. En alfa-form är en (vanligtvis) konkav polygonal geometri som innehåller alla indatavärdenas hörnpunkter och vars hörnpunkter är en delmängd av indatavärdenas hörnpunkter. En alfa-form ger en bättre anpassning till indatans form än den form som produceras av det konvexa skrovet.
"Passningsgraden" styrs av alfaparametern, som kan ha värden från 0 till oändligt. Mindre alfavärden ger mer konkava resultat. Alphavärden som är större än ett visst databeroende värde ger ett konvext skrov av indata.
![]() | |
Enligt CGAL-implementeringen är alfavärdet kvadraten på radien på den skiva som används i Alpha-Shape-algoritmen för att "erodera" Delaunay-trianguleringen av inmatningspunkterna. Se CGAL Alpha-Shapes för mer information. Detta skiljer sig från den ursprungliga definitionen av alpha-former, som definierar alfa som radien på den eroderande skivan. |
Den beräknade formen innehåller inga hål om inte det valfria argumentet allow_holes anges som true.
Denna funktion beräknar effektivt ett konkavt skrov av en geometri på ett liknande sätt som ST_ConcaveHull, men använder CGAL och en annan algoritm.
Tillgänglighet: 3.5.0 - kräver SFCGAL >= 1.4.1.
Denna metod behöver SFCGAL-backend.
The original point cloud and the alpha-shape share one comparison frame.
WITH data AS (
SELECT 'MULTIPOINT((63 84),(76 88),(68 73),(53 18),(91 50),(81 70),
(88 29),(24 82),(32 51),(37 23),(27 54),(84 19),(75 87),(44 42),(77 67),(90 30),(36 61),(32 65),
(81 47),(88 58),(68 73),(49 95),(81 60),(87 50),
(78 16),(79 21),(30 22),(78 43),(26 85),(48 34),(35 35),(36 40),(31 79),(83 29),(27 84),(52 98),(72 95),(85 71),
(75 84),(75 77),(81 29),(77 73),(41 42),(83 72),(23 36),(89 53),(27 57),(57 97),(27 77),(39 88),(60 81),
(80 72),(54 32),(55 26),(62 22),(70 20),(76 27),(84 35),(87 42),(82 54),(83 64),(69 86),(60 90),(50 86),(43 80),(36 73),
(36 68),(40 75),(24 67),(23 60),(26 44),(28 33),(40 32),(43 19),(65 16),(73 16),(38 46),(31 59),(34 86),(45 90),(64 97))'::geometry AS input_points
)
SELECT input_points AS input_points,
CG_AlphaShape(input_points, 80.2) AS alpha_shape
FROM data;MULTIPOINT((63 84),(76 88),(68 73),(53 18),(91 50),(81 70),(88 29),(24 82),(32 51),(37 23),(27 54),(84 19),(75 87),(44 42),(77 67),(90 30),(36 61),(32 65),(81 47),(88 58),(68 73),(49 95),(81 60),(87 50),(78 16),(79 21),(30 22),(78 43),(26 85),(48 34),(35 35),(36 40),(31 79),(83 29),(27 84),(52 98),(72 95),(85 71),(75 84),(75 77),(81 29),(77 73),(41 42),(83 72),(23 36),(89 53),(27 57),(57 97),(27 77),(39 88),(60 81),(80 72),(54 32),(55 26),(62 22),(70 20),(76 27),(84 35),(87 42),(82 54),(83 64),(69 86),(60 90),(50 86),(43 80),(36 73),(36 68),(40 75),(24 67),(23 60),(26 44),(28 33),(40 32),(43 19),(65 16),(73 16),(38 46),(31 59),(34 86),(45 90),(64 97)) | MULTIPOLYGON(((89 53,88 58,85 71,83 72,75 84,76 88,72 95,64 97,57 97,52 98,49 95,45 90,39 88,34 86,26 85,24 82,27 77,24 67,23 60,27 54,26 44,23 36,28 33,30 22,37 23,43 19,53 18,65 16,73 16,78 16,84 19,88 29,90 30,87 42,91 50,89 53)))
The same point cloud can produce a shape with a hole when holes are allowed.
WITH data AS (
SELECT 'MULTIPOINT((63 84),(76 88),(68 73),(53 18),(91 50),(81 70),(88 29),(24 82),(32 51),(37 23),(27 54),(84 19),(75 87),(44 42),(77 67),(90 30),(36 61),(32 65),(81 47),(88 58),(68 73),(49 95),(81 60),(87 50),
(78 16),(79 21),(30 22),(78 43),(26 85),(48 34),(35 35),(36 40),(31 79),(83 29),(27 84),(52 98),(72 95),(85 71),
(75 84),(75 77),(81 29),(77 73),(41 42),(83 72),(23 36),(89 53),(27 57),(57 97),(27 77),(39 88),(60 81),
(80 72),(54 32),(55 26),(62 22),(70 20),(76 27),(84 35),(87 42),(82 54),(83 64),(69 86),(60 90),(50 86),(43 80),(36 73),
(36 68),(40 75),(24 67),(23 60),(26 44),(28 33),(40 32),(43 19),(65 16),(73 16),(38 46),(31 59),(34 86),(45 90),(64 97))'::geometry AS input_points
)
SELECT input_points AS input_points,
CG_AlphaShape(input_points, 100.1, true) AS alpha_shape
FROM data;MULTIPOINT((63 84),(76 88),(68 73),(53 18),(91 50),(81 70),(88 29),(24 82),(32 51),(37 23),(27 54),(84 19),(75 87),(44 42),(77 67),(90 30),(36 61),(32 65),(81 47),(88 58),(68 73),(49 95),(81 60),(87 50),(78 16),(79 21),(30 22),(78 43),(26 85),(48 34),(35 35),(36 40),(31 79),(83 29),(27 84),(52 98),(72 95),(85 71),(75 84),(75 77),(81 29),(77 73),(41 42),(83 72),(23 36),(89 53),(27 57),(57 97),(27 77),(39 88),(60 81),(80 72),(54 32),(55 26),(62 22),(70 20),(76 27),(84 35),(87 42),(82 54),(83 64),(69 86),(60 90),(50 86),(43 80),(36 73),(36 68),(40 75),(24 67),(23 60),(26 44),(28 33),(40 32),(43 19),(65 16),(73 16),(38 46),(31 59),(34 86),(45 90),(64 97)) | MULTIPOLYGON(((89 53,88 58,85 71,83 72,75 84,76 88,72 95,64 97,57 97,52 98,49 95,45 90,39 88,34 86,26 85,24 82,27 77,24 67,23 60,27 54,26 44,23 36,28 33,30 22,43 19,53 18,65 16,73 16,78 16,84 19,90 30,87 42,91 50,89 53),(36 68,40 75,43 80,60 81,68 73,77 67,81 60,82 54,81 47,78 43,76 27,62 22,54 32,44 42,38 46,36 61,36 68)))
The second documented point cloud also produces a holed alpha-shape.
WITH data AS (
SELECT 'MULTIPOINT ((132 64),(114 64),(99 64),(81 64),(63 64),(57 49),(52 36),(46 20),(37 20),(26 20),(32 36),(39 55),(43 69),(50 84),(57 100),(63 118),(68 133),(74 149),(81 164),(88 180),(101 180),(112 180),(119 164),(126 149),(132 131),(139 113),(143 100),(150 84),(157 69),(163 51),(168 36),(174 20),(163 20),(150 20),(143 36),(139 49),(132 64),(99 151),(92 138),(88 124),(81 109),(74 93),(70 82),(83 82),(99 82),(112 82),(126 82),(121 96),(114 109),(110 122),(103 138),(99 151),(34 27),(43 31),(48 44),(46 58),(52 73),(63 73),(61 84),(72 71),(90 69),(101 76),(123 71),(141 62),(166 27),(150 33),(159 36),(146 44),(154 53),(152 62),(146 73),(134 76),(143 82),(141 91),(130 98),(126 104),(132 113),(128 127),(117 122),(112 133),(119 144),(108 147),(119 153),(110 171),(103 164),(92 171),(86 160),(88 142),(79 140),(72 124),(83 131),(79 118),(68 113),(63 102),(68 93),(35 45))'::geometry AS input_points
)
SELECT input_points AS input_points,
CG_AlphaShape(input_points, 102.2, true) AS alpha_shape
FROM data;MULTIPOINT((132 64),(114 64),(99 64),(81 64),(63 64),(57 49),(52 36),(46 20),(37 20),(26 20),(32 36),(39 55),(43 69),(50 84),(57 100),(63 118),(68 133),(74 149),(81 164),(88 180),(101 180),(112 180),(119 164),(126 149),(132 131),(139 113),(143 100),(150 84),(157 69),(163 51),(168 36),(174 20),(163 20),(150 20),(143 36),(139 49),(132 64),(99 151),(92 138),(88 124),(81 109),(74 93),(70 82),(83 82),(99 82),(112 82),(126 82),(121 96),(114 109),(110 122),(103 138),(99 151),(34 27),(43 31),(48 44),(46 58),(52 73),(63 73),(61 84),(72 71),(90 69),(101 76),(123 71),(141 62),(166 27),(150 33),(159 36),(146 44),(154 53),(152 62),(146 73),(134 76),(143 82),(141 91),(130 98),(126 104),(132 113),(128 127),(117 122),(112 133),(119 144),(108 147),(119 153),(110 171),(103 164),(92 171),(86 160),(88 142),(79 140),(72 124),(83 131),(79 118),(68 113),(63 102),(68 93),(35 45)) | MULTIPOLYGON(((168 36,163 51,157 69,150 84,143 100,139 113,132 131,126 149,119 164,112 180,101 180,88 180,81 164,74 149,68 133,63 118,57 100,50 84,43 69,39 55,35 45,32 36,26 20,37 20,46 20,52 36,57 49,63 64,81 64,90 69,99 64,114 64,132 64,139 49,143 36,150 20,163 20,174 20,168 36),(81 109,88 124,92 138,103 138,110 122,114 109,121 96,112 82,99 82,83 82,74 93,81 109)))
CG_ApproxConvexPartition — Beräknar approximal konvex partition av polygongeometrin
geometry CG_ApproxConvexPartition(geometry geom);
Beräknar approximal konvex partition av polygongeometrin (med hjälp av en triangulering).
![]() | |
En partition av en polygon P är en uppsättning polygoner som är sådana att polygonernas inre inte skär varandra och att polygonernas förening är lika med den ursprungliga polygonen P:s inre. Funktionerna CG_ApproxConvexPartition och CG_GreeneApproxConvexPartition producerar ungefärligt optimala konvexa partitioner. Båda dessa funktioner producerar konvexa uppdelningar genom att först dela upp polygonen i enklare polygoner; CG_ApproxConvexPartition använder en triangulering och CG_GreeneApproxConvexPartition en monoton uppdelning. Dessa två funktioner garanterar båda att de inte kommer att producera mer än fyra gånger det optimala antalet konvexa bitar, men de skiljer sig åt i deras körtidskomplexitet. Även om den trianguleringsbaserade approximationsalgoritmen ofta resulterar i färre konvexa bitar är detta inte alltid fallet. |
Tillgänglighet: 3.5.0 - kräver SFCGAL >= 1.5.0.
Kräver SFCGAL >= 1.5.0
Denna metod behöver SFCGAL-backend.
Approximate convex partition of the same polygon used by the other partition examples.
WITH data AS (
SELECT 'POLYGON((156 150,83 181,89 131,148 120,107 61,32 159,0 45,41 86,45 1,177 2,67 24,109 31,170 60,180 110,156 150))'::geometry AS input_polygon
)
SELECT input_polygon AS input_polygon,
CG_ApproxConvexPartition(input_polygon) AS partition
FROM data;POLYGON((156 150,83 181,89 131,148 120,107 61,32 159,0 45,41 86,45 1,177 2,67 24,109 31,170 60,180 110,156 150)) | GEOMETRYCOLLECTION(POLYGON((156 150,83 181,89 131,148 120,156 150)), POLYGON((32 159,0 45,41 86,32 159)), POLYGON((107 61,32 159,41 86,107 61)), POLYGON((45 1,177 2,67 24,45 1)), POLYGON((41 86,45 1,67 24,41 86)), POLYGON((107 61,41 86,67 24,109 31,107 61)), POLYGON((148 120,107 61,109 31,170 60,148 120)), POLYGON((156 150,148 120,170 60,180 110,156 150)))
CG_ApproximateMedialAxis — Beräkna den ungefärliga mediala axeln för en arealgeometri.
geometry CG_ApproximateMedialAxis(geometry geom);
geometry CG_ApproximateMedialAxis(geometry geom, boolean projected);
Returnerar en ungefärlig medial axel för den areella inmatningen baserat på dess raka skelett. Använder ett SFCGAL-specifikt API när det byggs mot en kapabel version (1.2.0+). Annars är funktionen bara ett omslag runt CG_StraightSkeleton (långsammare fall).
When projected is true, free endpoints of the medial axis are extended to reach the polygon boundary (projected medial axis). Requires SFCGAL 2.3.0+. When built against an older SFCGAL version, a notice is emitted and the non-projected result is returned instead.
Tillgänglighet: 3.5.0
Availability: 3.7.0 - projected parameter. Requires SFCGAL >= 2.3.0 for projected result; falls back to non-projected with a notice on older versions.
![]() | |
Denna funktion ignorerar Z-dimensionen. Den ger alltid ett 2D-resultat även när den används på en 3D-geometri. |
Denna metod behöver SFCGAL-backend.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
A polygon and its approximate medial axis.
WITH data AS (
SELECT 'POLYGON((190 190,10 190,10 10,190 10,190 20,160 30,60 30,60 130,190 140,190 190))'::geometry AS polygon
)
SELECT polygon AS input_polygon,
CG_ApproximateMedialAxis(polygon) AS medial_axis
FROM data;POLYGON((190 190,10 190,10 10,190 10,190 20,160 30,60 30,60 130,190 140,190 190)) | MULTILINESTRING((184.189 15.811,158.377 20),(50 20,158.377 20),(50 20,35 35),(35 153.151,35 35),(35 153.151,40.697 159.303),(164.04 164.04,40.697 159.303))
This example computes the projected medial axis with free endpoints extended to the polygon boundary.
SELECT CG_ApproximateMedialAxis('POLYGON((0 0,2 0,2 1,0 1,0 0))', true);MULTILINESTRING((0 0.5,0.5 0.5,1.5 0.5,2 0.5))
CG_GenerateFlatRoof — Generate a flat (box) roof from a footprint polygon.
geometry CG_GenerateFlatRoof(geometry geom, float8 height);
Generate a flat (box-shaped) roof as a 3D PolyhedralSurface Z from a 2D footprint polygon. The roof height above the ground plane is given by height (default 3.0).
Availability: 3.7.0 - requires SFCGAL >= 2.3.0.
Denna metod behöver SFCGAL-backend.
Denna funktion stöder polyedriska ytor.
Generate a flat roof two units above a rectangular footprint.
WITH data AS ( SELECT 'POLYGON((0 0,5 0,5 4,0 4,0 0))'::geometry AS footprint ) SELECT CG_GenerateFlatRoof(footprint, 2.0) AS roof FROM data;
POLYHEDRALSURFACE Z (((0 0 0,0 4 0,5 4 0,5 0 0,0 0 0)),((0 0 2,5 0 2,5 4 2,0 4 2,0 0 2)),((0 0 0,0 0 2,0 4 2,0 4 0,0 0 0)),((0 4 0,0 4 2,5 4 2,5 4 0,0 4 0)),((5 4 0,5 4 2,5 0 2,5 0 0,5 4 0)),((5 0 0,5 0 2,0 0 2,0 0 0,5 0 0)))
CG_GenerateHippedRoof — Generate a hipped roof from a footprint polygon.
geometry CG_GenerateHippedRoof(geometry geom, float8 height);
Generate a hipped roof as a 3D PolyhedralSurface Z from a 2D footprint polygon. All sides slope upward to meet at a ridge or apex. The roof height is given by height (default 3.0).
Availability: 3.7.0 - requires SFCGAL >= 2.3.0.
Denna metod behöver SFCGAL-backend.
Denna funktion stöder polyedriska ytor.
The footprint and hipped roof are shown side-by-side so the generated 3D faces do not hide behind the input footprint.
WITH data AS (
SELECT 'POLYGON((0 0,5 0,5 4,0 4,0 0))'::geometry AS input_footprint
)
SELECT input_footprint AS input_footprint,
CG_GenerateHippedRoof(input_footprint, 2.0) AS hipped_roof
FROM data;POLYGON((0 0,5 0,5 4,0 4,0 0)) | POLYHEDRALSURFACE Z (((0 4 0,5 4 0,5 0 0,0 0 0,0 4 0)),((0 4 0,0 0 0,2 2 2,0 4 0)),((0 0 0,5 0 0,3 2 2,2 2 2,0 0 0)),((5 0 0,5 4 0,3 2 2,5 0 0)),((5 4 0,0 4 0,2 2 2,3 2 2,5 4 0)))
CG_GenerateGableRoof — Generate a gable roof from a footprint polygon.
geometry CG_GenerateGableRoof(geometry geom, float8 height, float8 slope_angle);
Generate a gable roof as a 3D PolyhedralSurface Z from a 2D footprint polygon. Two opposite sides are vertical gable ends; the other two sides slope to a horizontal ridge. height sets the ridge height above the ground (default 3.0) and slope_angle controls the pitch in degrees (default 30.0). The SRID of the input geometry is preserved.
Availability: 3.7.0 - requires SFCGAL >= 2.3.0.
Denna metod behöver SFCGAL-backend.
Denna funktion stöder polyedriska ytor.
Generate a gable roof using a height of 2 and a 30 degree slope.
WITH data AS ( SELECT 'POLYGON((0 0,5 0,5 4,0 4,0 0))'::geometry AS footprint ) SELECT CG_GenerateGableRoof(footprint, 2.0, 30.0) AS roof FROM data;
POLYHEDRALSURFACE Z (((5 4 0,5 0 0,0 0 0,0 4 0,5 4 0)),((0 4 0,0 0 0,0 2 1.155,0 4 0)),((0 0 0,5 0 0,5 2 1.155,0 2 1.155,0 0 0)),((5 0 0,5 4 0,5 2 1.155,5 0 0)),((5 4 0,0 4 0,0 2 1.155,5 2 1.155,5 4 0)))
CG_GenerateSkillionRoof — Generate a skillion (single-slope) roof from a footprint polygon.
geometry CG_GenerateSkillionRoof(geometry geom, float8 height, float8 slope_angle, integer primary_edge_index);
Generate a skillion (single-slope, shed-style) roof as a 3D PolyhedralSurface Z from a 2D footprint polygon. The entire roof surface slopes in one direction. height sets the maximum ridge height (default 3.0), slope_angle sets the pitch in degrees (default 30.0), and primary_edge_index selects which polygon edge defines the high side (0-based, default 0).
When the combination of height and slope_angle would cause a side wall to vanish (the slope reaches the far edge before the full height is achieved), that face is omitted from the result. This means the number of output patches can vary depending on the parameters — a lower height relative to the footprint depth produces more faces than a taller, steeper configuration.
Availability: 3.7.0 - requires SFCGAL >= 2.3.0.
Denna metod behöver SFCGAL-backend.
Denna funktion stöder polyedriska ytor.
Height 2.0 produces 6 faces (all walls present); height 4.0 produces 5 faces (one side wall is filtered out because the slope reaches the far edge before the full height).
SELECT
ST_NumPatches(CG_GenerateSkillionRoof(
'POLYGON((0 0,5 0,5 4,0 4,0 0))', 2.0)) AS "height 2",
ST_NumPatches(CG_GenerateSkillionRoof(
'POLYGON((0 0,5 0,5 4,0 4,0 0))', 4.0)) AS "height 4";6 | 5
The height 2.0 result is shown with its footprint.
WITH data AS ( SELECT 'POLYGON((0 0,5 0,5 4,0 4,0 0))'::geometry AS footprint ) SELECT CG_GenerateSkillionRoof(footprint, 2.0) AS roof FROM data;
POLYHEDRALSURFACE Z (((0 4 0,5 4 0,5 0 0,0 0 0,0 4 0)),((5 0 2,5 4 2,3.464 4 2,3.464 0 2,5 0 2)),((0 4 0,0 0 0,3.464 0 2,3.464 4 2,0 4 0)),((0 0 0,5 0 0,5 0 2,3.464 0 2,0 0 0)),((5 0 0,5 4 0,5 4 2,5 0 2,5 0 0)),((5 4 0,0 4 0,3.464 4 2,5 4 2,5 4 0)))
CG_GenerateRoof — Generate a roof of the requested type from a footprint polygon.
geometry CG_GenerateRoof(geometry geom, text roof_type, float8 height, float8 slope_angle, integer primary_edge_index);
Generate a roof as a 3D PolyhedralSurface Z from a 2D footprint polygon. The roof_type parameter selects the roof style (default 'HIPPED'):
FLAT — flat box roof.
HIPPED — hipped roof (all sides slope to apex).
GABLE — gable roof (two sloping sides, two vertical ends).
SKILLION — single-slope (shed) roof.
height sets the roof height (default 3.0), slope_angle sets the pitch in degrees (default 30.0), and primary_edge_index selects the reference edge for skillion roofs (default 0).
Availability: 3.7.0 - requires SFCGAL >= 2.3.0.
Denna metod behöver SFCGAL-backend.
Denna funktion stöder polyedriska ytor.
The generic dispatcher returns the same 3D roofs as the specialized helpers for the same footprint.
WITH data AS (
SELECT 'POLYGON((0 0,4 0,4 4,0 4,0 0))'::geometry AS input_footprint
)
SELECT input_footprint AS input_footprint,
CG_GenerateRoof(input_footprint, 'HIPPED', 2.0, 30.0, 0) AS hipped_roof,
CG_GenerateRoof(input_footprint, 'FLAT', 2.0, 30.0, 0) AS flat_roof
FROM data;POLYGON((0 0,4 0,4 4,0 4,0 0)) | POLYHEDRALSURFACE Z (((0 4 0,4 4 0,4 0 0,0 0 0,0 4 0)),((0 4 0,0 0 0,2 2 2,0 4 0)),((0 0 0,4 0 0,2 2 2,0 0 0)),((4 0 0,4 4 0,2 2 2,4 0 0)),((4 4 0,0 4 0,2 2 2,4 4 0))) | POLYHEDRALSURFACE Z (((0 0 0,0 4 0,4 4 0,4 0 0,0 0 0)),((0 0 2,4 0 2,4 4 2,0 4 2,0 0 2)),((0 0 0,0 0 2,0 4 2,0 4 0,0 0 0)),((0 4 0,0 4 2,4 4 2,4 4 0,0 4 0)),((4 4 0,4 4 2,4 0 2,4 0 0,4 4 0)),((4 0 0,4 0 2,0 0 2,0 0 0,4 0 0)))
CG_PolygonRepair — Repair an invalid polygon or multipolygon.
geometry CG_PolygonRepair(geometry geom, text rule);
Repair an invalid polygon or multipolygon using CGAL's 2D Polygon Repair algorithm. Returns a MultiPolygon.
The rule parameter controls the repair strategy:
EVEN_ODD (default) — areas covered an odd number of times are kept. Available with CGAL 6.0+.
NON_ZERO — areas with non-zero winding number are kept. Requires CGAL 6.1+.
UNION — union of all input polygons. Requires CGAL 6.1+.
INTERSECTION — intersection of all input polygons. Requires CGAL 6.1+.
Availability: 3.7.0 - requires SFCGAL >= 2.3.0 and CGAL >= 6.0.
Denna metod behöver SFCGAL-backend.
Denna funktion stöder polyedriska ytor.
Repair a self-intersecting bowtie polygon with the default EVEN_ODD rule.
WITH data AS (
SELECT 'POLYGON((0 0,2 2,2 0,0 2,0 0))'::geometry AS input_polygon
)
SELECT input_polygon AS input_polygon,
CG_PolygonRepair(input_polygon) AS repaired_polygon
FROM data;POLYGON((0 0,2 2,2 0,0 2,0 0)) | MULTIPOLYGON(((0 0,1 1,0 2,0 0)),((1 1,2 0,2 2,1 1)))
With the UNION rule, all winding area is kept. This rule requires CGAL 6.1 or later.
WITH data AS (
SELECT 'POLYGON((0 0,2 2,2 0,0 2,0 0))'::geometry AS input_polygon
)
SELECT input_polygon AS input_polygon,
CG_PolygonRepair(input_polygon, 'UNION') AS repaired_polygon
FROM data;POLYGON((0 0,2 2,2 0,0 2,0 0)) | MULTIPOLYGON(((0 0,1 1,0 2,0 0)))
CG_ConstrainedDelaunayTriangles — Returnerar en begränsad Delaunay-triangulering runt den givna indatageometrin.
geometry CG_ConstrainedDelaunayTriangles(geometry g1);
Returnerar en begränsad Delaunay-triangulering runt topparna i indatageometrin. Utdata är en TIN.
Denna metod behöver SFCGAL-backend.
Tillgänglighet: 3.0.0
Denna funktion stöder 3d och kommer inte att tappa z-index.
Constrained Delaunay triangulation of the polygon and buffered point.
SELECT
CG_ConstrainedDelaunayTriangles(
ST_Union(
'POLYGON((175 150,20 40,50 60,125 100,175 150))'::geometry,
ST_Buffer('POINT(110 170)'::geometry, 20)
)
);TIN(((50 60,175 150,20 40,50 60)),((125 100,50 60,20 40,125 100)),((50 60,125 100,175 150,50 60)),((130 170,129.6 166.1,175 150,130 170)),((128.5 162.3,175 150,129.6 166.1,128.5 162.3)),((130 170,124.1 155.9,129.6 166.1,130 170)),((126.6 158.9,175 150,128.5 162.3,126.6 158.9)),((129.6 166.1,126.6 158.9,128.5 162.3,129.6 166.1)),((124.1 155.9,175 150,126.6 158.9,124.1 155.9)),((129.6 166.1,124.1 155.9,126.6 158.9,129.6 166.1)),((121.1 153.4,175 150,124.1 155.9,121.1 153.4)),((110 150,121.1 153.4,124.1 155.9,110 150)),((117.7 151.5,175 150,121.1 153.4,117.7 151.5)),((113.9 150.4,117.7 151.5,121.1 153.4,113.9 150.4)),((113.9 150.4,175 150,117.7 151.5,113.9 150.4)),((20 40,113.9 150.4,110 150,20 40)),((20 40,175 150,113.9 150.4,20 40)),((20 40,110 150,106.1 150.4,20 40)),((113.9 150.4,121.1 153.4,110 150,113.9 150.4)),((20 40,106.1 150.4,102.3 151.5,20 40)),((110 150,124.1 155.9,128.5 177.7,110 150)),((20 40,102.3 151.5,98.9 153.4,20 40)),((106.1 150.4,110 150,98.9 153.4,106.1 150.4)),((20 40,98.9 153.4,95.9 155.9,20 40)),((102.3 151.5,106.1 150.4,98.9 153.4,102.3 151.5)),((20 40,95.9 155.9,93.4 158.9,20 40)),((98.9 153.4,110 150,95.9 155.9,98.9 153.4)),((20 40,93.4 158.9,91.5 162.3,20 40)),((95.9 155.9,110 150,102.3 188.5,95.9 155.9)),((20 40,91.5 162.3,90.4 166.1,20 40)),((93.4 158.9,95.9 155.9,91.5 162.3,93.4 158.9)),((20 40,90.4 166.1,90 170,20 40)),((91.5 162.3,95.9 155.9,90 170,91.5 162.3)),((20 40,90 170,90.4 173.9,20 40)),((90.4 166.1,91.5 162.3,90 170,90.4 166.1)),((20 40,90.4 173.9,91.5 177.7,20 40)),((90 170,95.9 155.9,102.3 188.5,90 170)),((90.4 173.9,90 170,91.5 177.7,90.4 173.9)),((91.5 177.7,90 170,102.3 188.5,91.5 177.7)),((93.4 181.1,91.5 177.7,95.9 184.1,93.4 181.1)),((95.9 184.1,91.5 177.7,102.3 188.5,95.9 184.1)),((98.9 186.6,95.9 184.1,102.3 188.5,98.9 186.6)),((102.3 188.5,110 150,128.5 177.7,102.3 188.5)),((106.1 189.6,102.3 188.5,110 190,106.1 189.6)),((110 190,102.3 188.5,117.7 188.5,110 190)),((113.9 189.6,110 190,117.7 188.5,113.9 189.6)),((117.7 188.5,102.3 188.5,128.5 177.7,117.7 188.5)),((121.1 186.6,124.1 184.1,175 150,121.1 186.6)),((121.1 186.6,117.7 188.5,124.1 184.1,121.1 186.6)),((124.1 184.1,126.6 181.1,175 150,124.1 184.1)),((124.1 184.1,117.7 188.5,128.5 177.7,124.1 184.1)),((126.6 181.1,128.5 177.7,175 150,126.6 181.1)),((126.6 181.1,124.1 184.1,128.5 177.7,126.6 181.1)),((128.5 177.7,129.6 173.9,175 150,128.5 177.7)),((128.5 177.7,124.1 155.9,130 170,128.5 177.7)),((129.6 173.9,130 170,175 150,129.6 173.9)),((129.6 173.9,128.5 177.7,130 170,129.6 173.9)))
ST_DelaunayTriangles applied to the same input. Triangle edges cross polygon boundaries.
SELECT
ST_DelaunayTriangles(
ST_Union(
'POLYGON((175 150,20 40,50 60,125 100,175 150))'::geometry,
ST_Buffer('POINT(110 170)'::geometry, 20)
)
);GEOMETRYCOLLECTION(POLYGON((95.9 184.1,93.4 181.1,95.9 155.9,95.9 184.1)), POLYGON((95.9 184.1,95.9 155.9,102.3 188.5,95.9 184.1)), POLYGON((95.9 184.1,102.3 188.5,98.9 186.6,95.9 184.1)), POLYGON((102.3 188.5,95.9 155.9,98.9 153.4,102.3 188.5)), POLYGON((102.3 188.5,98.9 153.4,102.3 151.5,102.3 188.5)), POLYGON((102.3 188.5,102.3 151.5,106.1 189.6,102.3 188.5)), POLYGON((106.1 189.6,102.3 151.5,106.1 150.4,106.1 189.6)), POLYGON((106.1 189.6,106.1 150.4,110 190,106.1 189.6)), POLYGON((110 190,106.1 150.4,110 150,110 190)), POLYGON((110 190,110 150,117.7 188.5,110 190)), POLYGON((110 190,117.7 188.5,113.9 189.6,110 190)), POLYGON((117.7 188.5,110 150,121.1 153.4,117.7 188.5)), POLYGON((117.7 188.5,121.1 153.4,121.1 186.6,117.7 188.5)), POLYGON((121.1 186.6,121.1 153.4,124.1 155.9,121.1 186.6)), POLYGON((121.1 186.6,124.1 155.9,124.1 184.1,121.1 186.6)), POLYGON((121.1 186.6,124.1 184.1,175 150,121.1 186.6)), POLYGON((175 150,124.1 184.1,126.6 181.1,175 150)), POLYGON((175 150,126.6 181.1,128.5 177.7,175 150)), POLYGON((175 150,128.5 177.7,129.6 173.9,175 150)), POLYGON((175 150,129.6 173.9,130 170,175 150)), POLYGON((175 150,130 170,129.6 166.1,175 150)), POLYGON((175 150,129.6 166.1,128.5 162.3,175 150)), POLYGON((175 150,128.5 162.3,126.6 158.9,175 150)), POLYGON((175 150,126.6 158.9,124.1 155.9,175 150)), POLYGON((175 150,124.1 155.9,125 100,175 150)), POLYGON((125 100,124.1 155.9,121.1 153.4,125 100)), POLYGON((125 100,121.1 153.4,117.7 151.5,125 100)), POLYGON((125 100,117.7 151.5,113.9 150.4,125 100)), POLYGON((125 100,113.9 150.4,110 150,125 100)), POLYGON((125 100,110 150,106.1 150.4,125 100)), POLYGON((125 100,106.1 150.4,102.3 151.5,125 100)), POLYGON((125 100,102.3 151.5,98.9 153.4,125 100)), POLYGON((125 100,98.9 153.4,50 60,125 100)), POLYGON((125 100,50 60,20 40,125 100)), POLYGON((20 40,50 60,90.4 166.1,20 40)), POLYGON((20 40,90.4 166.1,90 170,20 40)), POLYGON((20 40,90 170,90.4 173.9,20 40)), POLYGON((20 40,90.4 173.9,91.5 177.7,20 40)), POLYGON((91.5 177.7,90.4 173.9,90 170,91.5 177.7)), POLYGON((91.5 177.7,90 170,91.5 162.3,91.5 177.7)), POLYGON((91.5 177.7,91.5 162.3,93.4 158.9,91.5 177.7)), POLYGON((91.5 177.7,93.4 158.9,93.4 181.1,91.5 177.7)), POLYGON((93.4 181.1,93.4 158.9,95.9 155.9,93.4 181.1)), POLYGON((95.9 155.9,93.4 158.9,50 60,95.9 155.9)), POLYGON((95.9 155.9,50 60,98.9 153.4,95.9 155.9)), POLYGON((50 60,93.4 158.9,91.5 162.3,50 60)), POLYGON((50 60,91.5 162.3,90.4 166.1,50 60)), POLYGON((90.4 166.1,91.5 162.3,90 170,90.4 166.1)), POLYGON((110 150,113.9 150.4,121.1 153.4,110 150)), POLYGON((121.1 153.4,113.9 150.4,117.7 151.5,121.1 153.4)), POLYGON((124.1 155.9,126.6 158.9,129.6 166.1,124.1 155.9)), POLYGON((124.1 155.9,129.6 166.1,128.5 177.7,124.1 155.9)), POLYGON((124.1 155.9,128.5 177.7,124.1 184.1,124.1 155.9)), POLYGON((124.1 184.1,128.5 177.7,126.6 181.1,124.1 184.1)), POLYGON((128.5 177.7,129.6 166.1,130 170,128.5 177.7)), POLYGON((128.5 177.7,130 170,129.6 173.9,128.5 177.7)), POLYGON((129.6 166.1,126.6 158.9,128.5 162.3,129.6 166.1)))
CG_Extrude — Extrudera en yta till en relaterad volym
geometry CG_Extrude(geometry geom, float x, float y, float z);
Extrudes the input along the vector (x, y, z) and connects it to its translated copy. Extrusion can raise the dimensionality of the result, for example from a surface to a volume.
Tillgänglighet: 3.5.0
Denna metod behöver SFCGAL-backend.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
The figures use ST_Affine to project Z diagonally into XY after extrusion. The returned geometry from CG_Extrude remains a 3D PolyhedralSurface.
Extruding an octagonal Polygon 30 units along Z.
WITH data AS (
SELECT ST_Buffer('POINT(100 90)'::geometry, 50, 'quad_segs=2') AS geom
), projected AS (
SELECT ST_Force2D(ST_Affine(geom,
1, 0, 0.5, 0, 1, 0.5, 0, 0, 0, 0, 0, 0)) AS input_geom,
ST_Force2D(ST_Affine(CG_Extrude(geom, 0, 0, 30),
1, 0, 0.5, 0, 1, 0.5, 0, 0, 0, 0, 0, 0)) AS output_geom
FROM data
)
SELECT input_geom AS input_geometry,
output_geom AS extruded_projection
FROM projected;POLYGON((150 90,135.355 54.645,100 40,64.645 54.645,50 90,64.645 125.355,100 140,135.355 125.355,150 90)) | POLYHEDRALSURFACE(((150 90,135.355 54.645,100 40,64.645 54.645,50 90,64.645 125.355,100 140,135.355 125.355,150 90)),((165 105,150.355 140.355,115 155,79.645 140.355,65 105,79.645 69.645,115 55,150.355 69.645,165 105)),((150 90,165 105,150.355 69.645,135.355 54.645,150 90)),((135.355 54.645,150.355 69.645,115 55,100 40,135.355 54.645)),((100 40,115 55,79.645 69.645,64.645 54.645,100 40)),((64.645 54.645,79.645 69.645,65 105,50 90,64.645 54.645)),((50 90,65 105,79.645 140.355,64.645 125.355,50 90)),((64.645 125.355,79.645 140.355,115 155,100 140,64.645 125.355)),((100 140,115 155,150.355 140.355,135.355 125.355,100 140)),((135.355 125.355,150.355 140.355,165 105,150 90,135.355 125.355)))
Extruding a LineString 10 units along Z.
WITH data AS (
SELECT 'LINESTRING(50 50,100 90,95 150)'::geometry AS geom
), projected AS (
SELECT ST_Force2D(ST_Affine(geom,
1, 0, 0.5, 0, 1, 0.5, 0, 0, 0, 0, 0, 0)) AS input_geom,
ST_Force2D(ST_Affine(CG_Extrude(geom, 0, 0, 10),
1, 0, 0.5, 0, 1, 0.5, 0, 0, 0, 0, 0, 0)) AS output_geom
FROM data
)
SELECT input_geom AS input_geometry,
output_geom AS extruded_projection
FROM projected;LINESTRING(50 50,100 90,95 150) | POLYHEDRALSURFACE(((50 50,100 90,105 95,55 55,50 50)),((100 90,95 150,100 155,105 95,100 90)))
CG_ExtrudeStraightSkeleton — Extrudering av raka skelett
geometry CG_ExtrudeStraightSkeleton(geometry geom, float roof_height, float body_height = 0);
Beräknar en profil med en maximal höjd på polygongeometrin.
![]() | |
Kanske det första (historiskt sett) användningsområdet för raka skelett: givet ett polygonalt tak ger det raka skelettet direkt layouten för varje tält. Om varje skelettkant lyfts från planet med en höjd som är lika med dess offsetavstånd, är det resulterande taket "korrekt" eftersom vatten alltid kommer att falla ner till konturkanterna (takets kant), oavsett var det faller på taket. Funktionen beräknar denna extrudering, även kallat "tak", på en polygon. Om argumentet body_height > 0, så extruderas polygonen på samma sätt som med CG_Extrude(polygon, 0, 0, body_height). Resultatet är en förening av dessa polyhedralsurfaces. |
Tillgänglighet: 3.5.0 - kräver SFCGAL >= 1.5.0.
Kräver SFCGAL >= 1.5.0
Denna metod behöver SFCGAL-backend.
Extrude a polygon with a hole into a body and straight-skeleton roof.
WITH data AS (
SELECT 'POLYGON ((0 0,5 0,5 5,4 5,4 4,0 4,0 0),(1 1,1 2,2 2,2 1,1 1))'::geometry AS input_polygon
)
SELECT input_polygon AS input_polygon,
CG_ExtrudeStraightSkeleton(input_polygon, 3.0, 2.0) AS straight_skeleton_extrusion
FROM data;POLYGON((0 0,5 0,5 5,4 5,4 4,0 4,0 0),(1 1,1 2,2 2,2 1,1 1)) | POLYHEDRALSURFACE Z (((0 0 0,0 4 0,4 4 0,4 5 0,5 5 0,5 0 0,0 0 0),(1 1 0,2 1 0,2 2 0,1 2 0,1 1 0)),((0 0 0,0 0 2,0 4 2,0 4 0,0 0 0)),((0 4 0,0 4 2,4 4 2,4 4 0,0 4 0)),((4 4 0,4 4 2,4 5 2,4 5 0,4 4 0)),((4 5 0,4 5 2,5 5 2,5 5 0,4 5 0)),((5 5 0,5 5 2,5 0 2,5 0 0,5 5 0)),((5 0 0,5 0 2,0 0 2,0 0 0,5 0 0)),((1 1 0,1 1 2,2 1 2,2 1 0,1 1 0)),((2 1 0,2 1 2,2 2 2,2 2 0,2 1 0)),((2 2 0,2 2 2,1 2 2,1 2 0,2 2 0)),((1 2 0,1 2 2,1 1 2,1 1 0,1 2 0)),((0 4 2,0 0 2,0.5 0.5 2.5,0.5 2.5 2.5,1 3 3,0 4 2)),((0 0 2,5 0 2,3.5 1.5 3.5,2.5 0.5 2.5,0.5 0.5 2.5,0 0 2)),((5 0 2,5 5 2,4.5 4.5 2.5,4.5 3.5 2.5,3.5 2.5 3.5,3.5 1.5 3.5,5 0 2)),((5 5 2,4 5 2,4.5 4.5 2.5,5 5 2)),((4 5 2,4 4 2,4.5 3.5 2.5,4.5 4.5 2.5,4 5 2)),((4 4 2,0 4 2,1 3 3,3 3 3,3.5 2.5 3.5,4.5 3.5 2.5,4 4 2)),((2 1 2,1 1 2,0.5 0.5 2.5,2.5 0.5 2.5,2 1 2)),((1 1 2,1 2 2,0.5 2.5 2.5,0.5 0.5 2.5,1 1 2)),((1 2 2,2 2 2,3 3 3,1 3 3,0.5 2.5 2.5,1 2 2)),((2 2 2,2 1 2,2.5 0.5 2.5,3.5 1.5 3.5,3.5 2.5 3.5,3 3 3,2 2 2)))
CG_GreeneApproxConvexPartition — Beräknar approximal konvex partition av polygongeometrin
geometry CG_GreeneApproxConvexPartition(geometry geom);
Beräknar approximal monoton konvex partition av polygongeometrin.
![]() | |
En partition av en polygon P är en uppsättning polygoner som är sådana att polygonernas inre inte skär varandra och att polygonernas förening är lika med den ursprungliga polygonen P:s inre. Funktionerna CG_ApproxConvexPartition och CG_GreeneApproxConvexPartition producerar ungefärligt optimala konvexa partitioner. Båda dessa funktioner producerar konvexa uppdelningar genom att först dela upp polygonen i enklare polygoner; CG_ApproxConvexPartition använder en triangulering och CG_GreeneApproxConvexPartition en monoton uppdelning. Dessa två funktioner garanterar båda att de inte kommer att producera mer än fyra gånger det optimala antalet konvexa bitar, men de skiljer sig åt i deras körtidskomplexitet. Även om den trianguleringsbaserade approximationsalgoritmen ofta resulterar i färre konvexa bitar är detta inte alltid fallet. |
Tillgänglighet: 3.5.0 - kräver SFCGAL >= 1.5.0.
Kräver SFCGAL >= 1.5.0
Denna metod behöver SFCGAL-backend.
Greene's monotone-based approximation uses the same polygon and stays directly comparable in one panel.
WITH data AS (
SELECT 'POLYGON((156 150,83 181,89 131,148 120,107 61,32 159,0 45,41 86,45 1,177 2,67 24,109 31,170 60,180 110,156 150))'::geometry AS input_polygon
)
SELECT input_polygon AS input_polygon,
CG_GreeneApproxConvexPartition(input_polygon) AS partition
FROM data;POLYGON((156 150,83 181,89 131,148 120,107 61,32 159,0 45,41 86,45 1,177 2,67 24,109 31,170 60,180 110,156 150)) | GEOMETRYCOLLECTION(POLYGON((32 159,0 45,41 86,32 159)), POLYGON((45 1,177 2,67 24,45 1)), POLYGON((67 24,109 31,170 60,107 61,67 24)), POLYGON((41 86,45 1,67 24,41 86)), POLYGON((107 61,32 159,41 86,67 24,107 61)), POLYGON((148 120,107 61,170 60,148 120)), POLYGON((148 120,170 60,180 110,156 150,148 120)), POLYGON((156 150,83 181,89 131,148 120,156 150)))
CG_MinkowskiSum — Utför Minkowski-summa
geometry CG_MinkowskiSum(geometry geom1, geometry geom2);
Denna funktion utför en 2D minkowski-summa av en punkt, linje eller polygon med en polygon.
En Minkowski-summa av två geometrier A och B är mängden av alla punkter som är summan av alla punkter i A och B. Minkowski-summor används ofta vid rörelseplanering och datorstödd design. Mer information på Wikipedia Minkowski addition.
Den första parametern kan vara en 2D-geometri (punkt, linestrings, polygon). Om en 3D-geometri skickas in kommer den att konverteras till 2D genom att tvinga Z till 0, vilket kan leda till ogiltiga fall. Den andra parametern måste vara en 2D-polygon.
Implementeringen använder CGAL 2D Minkowskisum.
Tillgänglighet: 3.5.0
Denna metod behöver SFCGAL-backend.
Minkowski sum of a LineString and a circular polygon. The line crosses the polygon, and the result sweeps the polygon along the line.
WITH data AS (
SELECT ST_MakeLine(ST_Point(10, 10), ST_Point(100, 100)) AS line,
ST_Buffer('POINT(50 50)'::geometry, 30) AS circle
)
SELECT line AS input_line,
circle AS input_circle,
CG_MinkowskiSum(line, circle) AS minkowski_sum
FROM data;LINESTRING(10 10,100 100) | POLYGON((80 50,79.424 44.147,77.716 38.519,74.944 33.333,71.213 28.787,66.667 25.056,61.481 22.284,55.853 20.576,50 20,44.147 20.576,38.519 22.284,33.333 25.056,28.787 28.787,25.056 33.333,22.284 38.519,20.576 44.147,20 50,20.576 55.853,22.284 61.481,25.056 66.667,28.787 71.213,33.333 74.944,38.519 77.716,44.147 79.424,50 80,55.853 79.424,61.481 77.716,66.667 74.944,71.213 71.213,74.944 66.667,77.716 61.481,79.424 55.853,80 50)) | MULTIPOLYGON(((179.424 155.853,177.716 161.481,174.944 166.667,171.213 171.213,166.667 174.944,161.481 177.716,155.853 179.424,150 180,144.147 179.424,138.519 177.716,133.333 174.944,128.787 171.213,38.787 81.213,35.056 76.667,32.284 71.481,30.576 65.853,30 60,30.576 54.147,32.284 48.519,35.056 43.333,38.787 38.787,43.333 35.056,48.519 32.284,54.147 30.576,60 30,65.853 30.576,71.481 32.284,76.667 35.056,81.213 38.787,171.213 128.787,174.944 133.333,177.716 138.519,179.424 144.147,180 150,179.424 155.853)))
Minkowski sum of a MultiPoint and a polygon. The result contains one translated copy of the polygon for each point.
WITH data AS (
SELECT 'MULTIPOINT(25 50,70 25)'::geometry AS points,
'POLYGON((130 150,20 40,50 60,125 100,130 150))'::geometry AS polygon
)
SELECT points AS input_points,
polygon AS input_polygon,
CG_MinkowskiSum(points, polygon) AS minkowski_sum
FROM data;MULTIPOINT((25 50),(70 25)) | POLYGON((130 150,20 40,50 60,125 100,130 150)) | MULTIPOLYGON(((45 90,75 110,150 150,155 200,45 90)),((90 65,120 85,195 125,200 175,90 65)))
CG_OptimalAlphaShape — Beräknar en alpha-form som omsluter en geometri med ett "optimalt" alpha-värde.
geometry CG_OptimalAlphaShape(geometry geom, boolean allow_holes = false, integer nb_components = 1);
Beräknar den "optimala" alfaformen för punkterna i en geometri. Alfaformen beräknas med hjälp av ett värde på α som väljs så att:
antalet polygonelement är lika med eller mindre än nb_components (som standard är 1)
alla inmatningspunkter ingår i formen
Resultatet kommer inte att innehålla hål om inte det valfria argumentet allow_holes anges som true.
Tillgänglighet: 3.5.0 - kräver SFCGAL >= 1.4.1.
Denna metod behöver SFCGAL-backend.
The original point cloud and the optimal alpha-shape share one comparison frame.
WITH data AS (
SELECT 'MULTIPOINT((63 84),(76 88),(68 73),(53 18),(91 50),(81 70),
(88 29),(24 82),(32 51),(37 23),(27 54),(84 19),(75 87),(44 42),(77 67),(90 30),(36 61),(32 65),
(81 47),(88 58),(68 73),(49 95),(81 60),(87 50),
(78 16),(79 21),(30 22),(78 43),(26 85),(48 34),(35 35),(36 40),(31 79),(83 29),(27 84),(52 98),(72 95),(85 71),
(75 84),(75 77),(81 29),(77 73),(41 42),(83 72),(23 36),(89 53),(27 57),(57 97),(27 77),(39 88),(60 81),
(80 72),(54 32),(55 26),(62 22),(70 20),(76 27),(84 35),(87 42),(82 54),(83 64),(69 86),(60 90),(50 86),(43 80),(36 73),
(36 68),(40 75),(24 67),(23 60),(26 44),(28 33),(40 32),(43 19),(65 16),(73 16),(38 46),(31 59),(34 86),(45 90),(64 97))'::geometry AS input_points
)
SELECT input_points AS input_points,
CG_OptimalAlphaShape(input_points) AS optimal_alpha_shape
FROM data;MULTIPOINT((63 84),(76 88),(68 73),(53 18),(91 50),(81 70),(88 29),(24 82),(32 51),(37 23),(27 54),(84 19),(75 87),(44 42),(77 67),(90 30),(36 61),(32 65),(81 47),(88 58),(68 73),(49 95),(81 60),(87 50),(78 16),(79 21),(30 22),(78 43),(26 85),(48 34),(35 35),(36 40),(31 79),(83 29),(27 84),(52 98),(72 95),(85 71),(75 84),(75 77),(81 29),(77 73),(41 42),(83 72),(23 36),(89 53),(27 57),(57 97),(27 77),(39 88),(60 81),(80 72),(54 32),(55 26),(62 22),(70 20),(76 27),(84 35),(87 42),(82 54),(83 64),(69 86),(60 90),(50 86),(43 80),(36 73),(36 68),(40 75),(24 67),(23 60),(26 44),(28 33),(40 32),(43 19),(65 16),(73 16),(38 46),(31 59),(34 86),(45 90),(64 97)) | MULTIPOLYGON(((89 53,88 58,83 64,85 71,83 72,75 77,75 84,76 88,72 95,64 97,57 97,52 98,49 95,45 90,39 88,34 86,26 85,24 82,27 77,24 67,23 60,27 54,26 44,23 36,28 33,30 22,37 23,43 19,53 18,65 16,73 16,78 16,84 19,88 29,90 30,87 42,91 50,89 53)))
Allowing holes keeps the same outer shell but carves a central hole.
WITH data AS (
SELECT 'MULTIPOINT((63 84),(76 88),(68 73),(53 18),(91 50),(81 70),(88 29),(24 82),(32 51),(37 23),(27 54),(84 19),(75 87),(44 42),(77 67),(90 30),(36 61),(32 65),(81 47),(88 58),(68 73),(49 95),(81 60),(87 50),
(78 16),(79 21),(30 22),(78 43),(26 85),(48 34),(35 35),(36 40),(31 79),(83 29),(27 84),(52 98),(72 95),(85 71),
(75 84),(75 77),(81 29),(77 73),(41 42),(83 72),(23 36),(89 53),(27 57),(57 97),(27 77),(39 88),(60 81),
(80 72),(54 32),(55 26),(62 22),(70 20),(76 27),(84 35),(87 42),(82 54),(83 64),(69 86),(60 90),(50 86),(43 80),(36 73),
(36 68),(40 75),(24 67),(23 60),(26 44),(28 33),(40 32),(43 19),(65 16),(73 16),(38 46),(31 59),(34 86),(45 90),(64 97))'::geometry AS input_points
)
SELECT input_points AS input_points,
CG_OptimalAlphaShape(input_points, allow_holes => true) AS optimal_alpha_shape
FROM data;MULTIPOINT((63 84),(76 88),(68 73),(53 18),(91 50),(81 70),(88 29),(24 82),(32 51),(37 23),(27 54),(84 19),(75 87),(44 42),(77 67),(90 30),(36 61),(32 65),(81 47),(88 58),(68 73),(49 95),(81 60),(87 50),(78 16),(79 21),(30 22),(78 43),(26 85),(48 34),(35 35),(36 40),(31 79),(83 29),(27 84),(52 98),(72 95),(85 71),(75 84),(75 77),(81 29),(77 73),(41 42),(83 72),(23 36),(89 53),(27 57),(57 97),(27 77),(39 88),(60 81),(80 72),(54 32),(55 26),(62 22),(70 20),(76 27),(84 35),(87 42),(82 54),(83 64),(69 86),(60 90),(50 86),(43 80),(36 73),(36 68),(40 75),(24 67),(23 60),(26 44),(28 33),(40 32),(43 19),(65 16),(73 16),(38 46),(31 59),(34 86),(45 90),(64 97)) | MULTIPOLYGON(((89 53,88 58,83 64,85 71,83 72,75 77,75 84,76 88,72 95,64 97,57 97,52 98,49 95,45 90,39 88,34 86,26 85,24 82,27 77,24 67,23 60,27 54,26 44,23 36,28 33,30 22,37 23,43 19,53 18,65 16,73 16,78 16,84 19,88 29,90 30,87 42,91 50,89 53),(36 68,40 75,43 80,50 86,60 81,68 73,77 67,81 60,82 54,81 47,78 43,81 29,76 27,70 20,62 22,55 26,54 32,48 34,44 42,38 46,36 61,36 68)))
CG_OptimalConvexPartition — Beräknar en optimal konvex partition av polygongeometrin
geometry CG_OptimalConvexPartition(geometry geom);
Beräknar en optimal konvex partition av polygongeometrin.
![]() | |
En partition av en polygon P är en uppsättning polygoner som är sådana att polygonernas insidor inte skär varandra och att polygonernas förening är lika med insidan av den ursprungliga polygonen P. CG_OptimalConvexPartition producerar en partition som är optimal med avseende på antalet delar. |
Tillgänglighet: 3.5.0 - kräver SFCGAL >= 1.5.0.
Kräver SFCGAL >= 1.5.0
Denna metod behöver SFCGAL-backend.
The optimal convex partition uses the same polygon and produces the smallest documented piece count.
WITH data AS (
SELECT 'POLYGON((156 150,83 181,89 131,148 120,107 61,32 159,0 45,41 86,45 1,177 2,67 24,109 31,170 60,180 110,156 150))'::geometry AS input_polygon
)
SELECT input_polygon AS input_polygon,
CG_OptimalConvexPartition(input_polygon) AS partition
FROM data;POLYGON((156 150,83 181,89 131,148 120,107 61,32 159,0 45,41 86,45 1,177 2,67 24,109 31,170 60,180 110,156 150)) | GEOMETRYCOLLECTION(POLYGON((156 150,83 181,89 131,148 120,156 150)), POLYGON((32 159,0 45,41 86,32 159)), POLYGON((45 1,177 2,67 24,45 1)), POLYGON((41 86,45 1,67 24,41 86)), POLYGON((107 61,32 159,41 86,67 24,109 31,107 61)), POLYGON((148 120,107 61,109 31,170 60,180 110,148 120)), POLYGON((156 150,148 120,180 110,156 150)))
CG_StraightSkeleton — Beräkna ett rakt skelett från en geometri
geometry CG_StraightSkeleton(geometry geom, boolean use_distance_as_m = false);
Computes the straight skeleton of a polygon by tracing the inward propagation of its edges. When use_distance_as_m is true, the M coordinate of each output point stores its distance from the input boundary.
Tillgänglighet: 3.5.0
Kräver SFCGAL >= 1.3.8 för alternativet use_distance_as_m
Denna metod behöver SFCGAL-backend.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
WITH data AS ( SELECT 'POLYGON((190 190,10 190,10 10,190 10,190 20,160 30,60 30,60 130,190 140,190 190))'::geometry AS polygon ) SELECT CG_StraightSkeleton(polygon) AS straight_skeleton FROM data;
MULTILINESTRING((190 190,164.03987973986756 164.03987973986756),(10 190,40.697077206292434 159.30292279370755),(10 10,35 35),(190 10,184.18861169915812 15.811388300841896),(190 20,184.18861169915812 15.811388300841896),(160 30,158.3772233983162 20),(60 30,50 20),(60 130,35 153.15077848154866),(190 140,164.03987973986756 164.03987973986756),(184.18861169915812 15.811388300841896,158.3772233983162 20),(50 20,158.3772233983162 20),(50 20,35 35),(35 153.15077848154866,35 35),(35 153.15077848154866,40.697077206292434 159.30292279370755),(164.03987973986756 164.03987973986756,40.697077206292434 159.30292279370755))
WITH data AS ( SELECT 'POLYGON((0 0,1 0,1 1,0 1,0 0))'::geometry AS polygon ) SELECT CG_StraightSkeleton(polygon, true) AS straight_skeleton_with_m FROM data;
MULTILINESTRING M ((0 0 0,0.5 0.5 0.5),(1 0 0,0.5 0.5 0.5),(1 1 0,0.5 0.5 0.5),(0 1 0,0.5 0.5 0.5))
Observera att giltiga inmatningar med ringar som rör vid en enda punkt kommer att ge upphov till ett fel.
SELECT CG_StraightSkeleton('POLYGON((0 0,3 0,3 3,0 3,0 0),(0 0,1 2,2 1,0 0))'));NOTICE: During straight_skeleton(A) : NOTICE: with A: POLYGON((0/1 0/1,3/1 0/1,3/1 3/1,0/1 3/1,0/1 0/1),(0/1 0/1,1/1 2/1,2/1 1/1,0/1 0/1)) ERROR: straight skeleton of Polygon with point touching rings is not implemented.
CG_Tesselate — Tessellerar ytan på en polygon eller polyederyta och returnerar som en TIN eller en samling av TINS
geometry CG_Tesselate(geometry geom);
Tar som indata en yta som MULTI(POLYGON) eller POLYHEDRALSURFACE och returnerar en TIN-representation via tessellationsprocessen med hjälp av trianglar.
![]() | |
ST_TriangulatePolygon liknar denna funktion förutom att den returnerar en geometrisamling av polygoner istället för en TIN och dessutom endast fungerar med 2D-geometrier. |
Tillgänglighet: 3.5.0
Denna metod behöver SFCGAL-backend.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
Tessellation divides each face of a cube into triangles.
WITH data AS ( SELECT 'POLYHEDRALSURFACE Z( ((0 0 0,0 0 1,0 1 1,0 1 0,0 0 0)), ((0 0 0,0 1 0,1 1 0,1 0 0,0 0 0)),((0 0 0,1 0 0,1 0 1,0 0 1,0 0 0)), ((1 1 0,1 1 1,1 0 1,1 0 0,1 1 0)), ((0 1 0,0 1 1,1 1 1,1 1 0,0 1 0)),((0 0 1,1 0 1,1 1 1,0 1 1,0 0 1)) )'::geometry AS cube ) SELECT CG_Tesselate(cube) AS tessellation FROM data;
TIN Z (((0 0 0,0 0 1,0 1 1,0 0 0)),((0 1 0,0 0 0,0 1 1,0 1 0)),((0 0 0,0 1 0,1 1 0,0 0 0)),((1 0 0,0 0 0,1 1 0,1 0 0)),((0 0 1,1 0 0,1 0 1,0 0 1)),((0 0 1,0 0 0,1 0 0,0 0 1)),((1 1 0,1 1 1,1 0 1,1 1 0)),((1 0 0,1 1 0,1 0 1,1 0 0)),((0 1 0,0 1 1,1 1 1,0 1 0)),((1 1 0,0 1 0,1 1 1,1 1 0)),((0 1 1,1 0 1,1 1 1,0 1 1)),((0 1 1,0 0 1,1 0 1,0 1 1)))
Tessellation of a Polygon.
WITH data AS (
SELECT 'POLYGON((10 190,10 70,80 70,80 130,50 160,120 160,120 190,10 190))'::geometry AS polygon
)
SELECT polygon AS input_polygon,
CG_Tesselate(polygon) AS tessellation
FROM data;POLYGON((10 190,10 70,80 70,80 130,50 160,120 160,120 190,10 190)) | TIN(((80 130,10 70,80 70,80 130)),((50 160,10 190,10 70,50 160)),((80 130,50 160,10 70,80 130)),((120 160,120 190,50 160,120 160)),((120 190,10 190,50 160,120 190)))
CG_Triangulate — Triangulerar en polygonal geometri
geometry CG_Triangulate( geometry geom );
Triangulerar en polygonal geometri.
Utförs av SFCGAL-modulen
![]() | |
OBS: Denna funktion returnerar en geometri som representerar det triangulerade resultatet. |
Tillgänglighet: 3.5.0
Denna metod behöver SFCGAL-backend.
SELECT CG_Triangulate(
'POLYGON((0 0,1 0,1 1,0 1,0 0),
(0.2 0.2,0.2 0.8,0.8 0.8,0.8 0.2,0.2 0.2))'
);TIN(((0.8 0.2,0.2 0.2,1 0,0.8 0.2)),((0.2 0.2,0 0,1 0,0.2 0.2)),((1 1,0.8 0.8,0.8 0.2,1 1)),((0 1,0 0,0.2 0.2,0 1)),((0 1,0.2 0.8,1 1,0 1)),((0 1,0.2 0.2,0.2 0.8,0 1)),((0.2 0.8,0.8 0.8,1 1,0.2 0.8)),((0.2 0.8,0.2 0.2,0.8 0.2,0.2 0.8)),((1 1,0.8 0.2,1 0,1 1)),((0.8 0.8,0.2 0.8,0.8 0.2,0.8 0.8)))
CG_Visibility — Beräkna en synlighetspolygon från en punkt eller ett segment i en polygongeometri
geometry CG_Visibility(geometry polygon, geometry point);
geometry CG_Visibility(geometry polygon, geometry pointA, geometry pointB);
Returns the portion of a polygon visible from an observer point, or from the observer segment defined by pointA and pointB.
Tillgänglighet: 3.5.0 - kräver SFCGAL >= 1.5.0.
Kräver SFCGAL >= 1.5.0
Denna metod behöver SFCGAL-backend.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder polyedriska ytor.
Denna funktion stöder trianglar och triangulerade oregelbundna nätverksytor (TIN).
Visibility from a point inside a polygon with holes.
WITH data AS (
SELECT 'POLYGON((23.5 23.5,23.5 173.5,173.5 173.5,173.5 23.5,23.5 23.5),(108 98,108 36,156 37,155 99,108 98),(107 157.5,107 106.5,135 107.5,133 127.5,143.5 127.5,143.5 108.5,153.5 109.5,151.5 166,107 157.5),(41 95.5,41 35,100.5 36,98.5 68,78.5 68,77.5 96.5,41 95.5),(39 150,40 104,97.5 106.5,95.5 152,39 150))'::geometry AS polygon,
'POINT(91 87)'::geometry AS observer
)
SELECT ST_Collect(polygon, observer) AS input_scene,
CG_Visibility(polygon, observer) AS visibility
FROM data;GEOMETRYCOLLECTION(POLYGON((23.5 23.5,23.5 173.5,173.5 173.5,173.5 23.5,23.5 23.5),(108 98,108 36,156 37,155 99,108 98),(107 157.5,107 106.5,135 107.5,133 127.5,143.5 127.5,143.5 108.5,153.5 109.5,151.5 166,107 157.5),(41 95.5,41 35,100.5 36,98.5 68,78.5 68,77.5 96.5,41 95.5),(39 150,40 104,97.5 106.5,95.5 152,39 150)), POINT(91 87)) | POLYGON((78.5 68,98.5 68,108 43.93333333333334,108 98,121.96219931271477 107.03436426116838,107 106.5,107 135,97.5 106.5,65.28017241379311 105.09913793103448,77.5 96.5,78.5 68))
Visibility from a segment inside the same polygon.
WITH data AS (
SELECT 'POLYGON((23.5 23.5,23.5 173.5,173.5 173.5,173.5 23.5,23.5 23.5),(108 98,108 36,156 37,155 99,108 98),(107 157.5,107 106.5,135 107.5,133 127.5,143.5 127.5,143.5 108.5,153.5 109.5,151.5 166,107 157.5),(41 95.5,41 35,100.5 36,98.5 68,78.5 68,77.5 96.5,41 95.5),(39 150,40 104,97.5 106.5,95.5 152,39 150))'::geometry AS polygon,
'LINESTRING(78.5 68,98.5 68)'::geometry AS observer
)
SELECT ST_Collect(polygon, observer) AS input_scene,
CG_Visibility(polygon,
ST_StartPoint(observer),
ST_EndPoint(observer)) AS visibility
FROM data;GEOMETRYCOLLECTION(POLYGON((23.5 23.5,23.5 173.5,173.5 173.5,173.5 23.5,23.5 23.5),(108 98,108 36,156 37,155 99,108 98),(107 157.5,107 106.5,135 107.5,133 127.5,143.5 127.5,143.5 108.5,153.5 109.5,151.5 166,107 157.5),(41 95.5,41 35,100.5 36,98.5 68,78.5 68,77.5 96.5,41 95.5),(39 150,40 104,97.5 106.5,95.5 152,39 150)), LINESTRING(78.5 68,98.5 68)) | POLYGON((78.5 68,98.5 68,100.5 36,101.28125 23.5,111.7109375 23.5,108 36,108 98,110.73389524382901 106.63335340156533,107 106.5,107 157.5,108.51955307262571 173.5,95.75974025974025 173.5,97.5 106.5,70.9811529933481 105.3470066518847,77.5 96.5,78.5 68))
CG_YMonotonePartition — Beräknar y-monoton partition av polygongeometrin
geometry CG_YMonotonePartition(geometry geom);
Beräknar y-monoton partition av polygongeometrin.
![]() | |
En partition av en polygon P är en uppsättning polygoner som är sådana att polygonernas inre delar inte skär varandra och att polygonernas förening är lika med den ursprungliga polygonen P:s inre del. En y-monoton polygon är en polygon vars hörn v1,...,vn kan delas upp i två kedjor v1,...,vk och vk,...,vn,v1, så att varje horisontell linje skär endera kedjan högst en gång. Denna algoritm garanterar inte en gräns för antalet polygoner som produceras i förhållande till det optimala antalet. |
Tillgänglighet: 3.5.0 - kräver SFCGAL >= 1.5.0.
Kräver SFCGAL >= 1.5.0
Denna metod behöver SFCGAL-backend.
The same polygon can also be partitioned into y-monotone pieces for downstream processing.
WITH data AS (
SELECT 'POLYGON((156 150,83 181,89 131,148 120,107 61,32 159,0 45,41 86,45 1,177 2,67 24,109 31,170 60,180 110,156 150))'::geometry AS input_polygon
)
SELECT input_polygon AS input_polygon,
CG_YMonotonePartition(input_polygon) AS partition
FROM data;POLYGON((156 150,83 181,89 131,148 120,107 61,32 159,0 45,41 86,45 1,177 2,67 24,109 31,170 60,180 110,156 150)) | GEOMETRYCOLLECTION(POLYGON((32 159,0 45,41 86,32 159)), POLYGON((107 61,32 159,41 86,45 1,177 2,67 24,109 31,170 60,107 61)), POLYGON((156 150,83 181,89 131,148 120,107 61,170 60,180 110,156 150)))
CG_StraightSkeletonPartition — Beräknar den raka skelettpartitionen av en polygon.
geometry CG_StraightSkeletonPartition(geometry geom, boolean auto_orientation);
Beräknar den raka skelettpartitionen av den inmatade polygongeometrin geom. Det raka skelettet är en partitionering av polygonen i ytor som bildas genom att spåra kollapsen av dess kanter. Om auto_orientation är satt till true kommer funktionen automatiskt att justera indatapolygonens orientering för att säkerställa korrekta resultat.
Tillgänglighet: 3.6.0 - kräver SFCGAL >= 2.0.0.
Denna metod behöver SFCGAL-backend.
SELECT CG_StraightSkeletonPartition('POLYGON((0 0,4 0,2 2,0 0))', true);POLYHEDRALSURFACE(((0 0,2 0.82842712474619,2 2,0 0)),((4 0,2 0.82842712474619,0 0,4 0)),((2 2,2 0.82842712474619,4 0,2 2)))
Straight skeleton partition of a polygon.
WITH data AS (
SELECT 'POLYGON((190 190,10 190,10 10,190 10,190 20,160 30,60 30,60 130,190 140,190 190))'::geometry AS polygon
)
SELECT polygon AS input_polygon,
CG_StraightSkeletonPartition(polygon, true) AS skeleton_partition
FROM data;POLYGON((190 190,10 190,10 10,190 10,190 20,160 30,60 30,60 130,190 140,190 190)) | POLYHEDRALSURFACE(((190 190,164.04 164.04,190 140,190 190)),((10 190,40.697 159.303,164.04 164.04,190 190,10 190)),((10 10,35 35,35 153.151,40.697 159.303,10 190,10 10)),((190 10,184.189 15.811,158.377 20,50 20,35 35,10 10,190 10)),((190 20,184.189 15.811,190 10,190 20)),((160 30,158.377 20,184.189 15.811,190 20,160 30)),((60 30,50 20,158.377 20,160 30,60 30)),((60 130,35 153.151,35 35,50 20,60 30,60 130)),((190 140,164.04 164.04,40.697 159.303,35 153.151,60 130,190 140)))
CG_3DBuffer — Beräknar en 3D-buffert runt en geometri.
geometry CG_3DBuffer(geometry geom, float8 radius, integer segments, integer buffer_type);
Genererar en 3D-buffert runt indatageometrin geom med en angiven radie. Bufferten konstrueras i 3D-rymd och skapar en volymetrisk representation av geometrins omgivning. Parametern segments definierar antalet segment som används för att approximera de krökta delarna av bufferten, med ett minimivärde på 4 segment. Parametern buffer_type anger vilken typ av buffert som ska skapas: 0: Rundad buffert (standard) 1: Platt buffert 2: Kvadratisk buffert
Indatageometrin måste vara en Point eller LineString.
Tillgänglighet: 3.6.0 - kräver SFCGAL >= 2.0.0
Denna metod behöver SFCGAL-backend.
SELECT CG_3DBuffer('POINT(0 0 0)', 1, 8, 0);POLYHEDRALSURFACE Z (((0 0 1, 0.5 -0.5 0.71, 0 -0.71 0.71, 0 0 1)), ... )
A rounded point buffer using 32 segments.
SELECT
'POINT(100 90)'::geometry AS input_geometry,
CG_3DBuffer('POINT(100 90)'::geometry, 50, 32, 0) AS buffer;POINT(100 90) | POLYHEDRALSURFACE Z (((74 133 0,66 126 7,78 133 12,74 133 0)),((60 115 15,71 124 21,66 126 7,60 115 15)),((85 130 25,78 133 12,71 124 21,85 130 25)),((66 126 7,71 124 21,78 133 12,66 126 7)),((57 90 26,64 97 34,57 102 22,57 90 26)),((75 105 40,66 111 29,64 97 34,75 105 40)),((60 115 15,57 102 22,66 111 29,60 115 15)),((64 97 34,66 111 29,57 102 22,64 97 34)),((100 116 43,93 124 36,88 112 43,100 116 43)),((85 130 25,79 119 34,93 124 36,85 130 25)),((75 105 40,88 112 43,79 119 34,75 105 40)),((93 124 36,79 119 34,88 112 43,93 124 36)),((60 115 15,66 111 29,71 124 21,60 115 15)),((75 105 40,79 119 34,66 111 29,75 105 40)),((85 130 25,71 124 21,79 119 34,85 130 25)),((66 111 29,79 119 34,71 124 21,66 111 29)),((74 133 0,78 133 12,85 138 0,74 133 0)),((85 130 25,92 138 13,78 133 12,85 130 25)),((100 140 0,85 138 0,92 138 13,100 140 0)),((78 133 12,92 138 13,85 138 0,78 133 12)),((100 116 43,107 124 36,93 124 36,100 116 43)),((115 130 25,100 133 26,107 124 36,115 130 25)),((85 130 25,93 124 36,100 133 26,85 130 25)),((107 124 36,100 133 26,93 124 36,107 124 36)),((126 133 0,115 138 0,122 133 12,126 133 0)),((100 140 0,108 138 13,115 138 0,100 140 0)),((115 130 25,122 133 12,108 138 13,115 130 25)),((115 138 0,108 138 13,122 133 12,115 138 0)),((85 130 25,100 133 26,92 138 13,85 130 25)),((115 130 25,108 138 13,100 133 26,115 130 25)),((100 140 0,92 138 13,108 138 13,100 140 0)),((100 133 26,108 138 13,92 138 13,100 133 26)),((74 133 0,85 138 0,78 133 -12,74 133 0)),((100 140 0,92 138 -13,85 138 0,100 140 0)),((85 130 -25,78 133 -12,92 138 -13,85 130 -25)),((85 138 0,92 138 -13,78 133 -12,85 138 0)),((126 133 0,122 133 -12,115 138 0,126 133 0)),((115 130 -25,108 138 -13,122 133 -12,115 130 -25)),((100 140 0,115 138 0,108 138 -13,100 140 0)),((122 133 -12,108 138 -13,115 138 0,122 133 -12)),((100 116 -43,93 124 -36,107 124 -36,100 116 -43)),((85 130 -25,100 133 -26,93 124 -36,85 130 -25)),((115 130 -25,107 124 -36,100 133 -26,115 130 -25)),((93 124 -36,100 133 -26,107 124 -36,93 124 -36)),((100 140 0,108 138 -13,92 138 -13,100 140 0)),((115 130 -25,100 133 -26,108 138 -13,115 130 -25)),((85 130 -25,92 138 -13,100 133 -26,85 130 -25)),((108 138 -13,100 133 -26,92 138 -13,108 138 -13)),((74 133 0,78 133 -12,66 126 -7,74 133 0)),((85 130 -25,71 124 -21,78 133 -12,85 130 -25)),((60 115 -15,66 126 -7,71 124 -21,60 115 -15)),((78 133 -12,71 124 -21,66 126 -7,78 133 -12)),((100 116 -43,88 112 -43,93 124 -36,100 116 -43)),((75 105 -40,79 119 -34,88 112 -43,75 105 -40)),((85 130 -25,93 124 -36,79 119 -34,85 130 -25)),((88 112 -43,79 119 -34,93 124 -36,88 112 -43)),((57 90 -26,57 102 -22,64 97 -34,57 90 -26)),((60 115 -15,66 111 -29,57 102 -22,60 115 -15)),((75 105 -40,64 97 -34,66 111 -29,75 105 -40)),((57 102 -22,66 111 -29,64 97 -34,57 102 -22)),((85 130 -25,79 119 -34,71 124 -21,85 130 -25)),((75 105 -40,66 111 -29,79 119 -34,75 105 -40)),((60 115 -15,71 124 -21,66 111 -29,60 115 -15)),((79 119 -34,66 111 -29,71 124 -21,79 119 -34)),((74 133 0,66 126 -7,66 126 7,74 133 0)),((60 115 -15,57 116 0,66 126 -7,60 115 -15)),((60 115 15,66 126 7,57 116 0,60 115 15)),((66 126 -7,57 116 0,66 126 7,66 126 -7)),((57 90 -26,52 90 -15,57 102 -22,57 90 -26)),((50 90 0,52 103 -8,52 90 -15,50 90 0)),((60 115 -15,57 102 -22,52 103 -8,60 115 -15)),((52 90 -15,52 103 -8,57 102 -22,52 90 -15)),((57 90 26,57 102 22,52 90 15,57 90 26)),((60 115 15,52 103 8,57 102 22,60 115 15)),((50 90 0,52 90 15,52 103 8,50 90 0)),((57 102 22,52 103 8,52 90 15,57 102 22)),((60 115 -15,52 103 -8,57 116 0,60 115 -15)),((50 90 0,52 103 8,52 103 -8,50 90 0)),((60 115 15,57 116 0,52 103 8,60 115 15)),((52 103 -8,52 103 8,57 116 0,52 103 -8)),((126 133 0,122 133 12,134 126 7,126 133 0)),((115 130 25,129 124 21,122 133 12,115 130 25)),((140 115 15,134 126 7,129 124 21,140 115 15)),((122 133 12,129 124 21,134 126 7,122 133 12)),((100 116 43,112 112 43,107 124 36,100 116 43)),((125 105 40,121 119 34,112 112 43,125 105 40)),((115 130 25,107 124 36,121 119 34,115 130 25)),((112 112 43,121 119 34,107 124 36,112 112 43)),((143 90 26,143 102 22,136 97 34,143 90 26)),((140 115 15,134 111 29,143 102 22,140 115 15)),((125 105 40,136 97 34,134 111 29,125 105 40)),((143 102 22,134 111 29,136 97 34,143 102 22)),((115 130 25,121 119 34,129 124 21,115 130 25)),((125 105 40,134 111 29,121 119 34,125 105 40)),((140 115 15,129 124 21,134 111 29,140 115 15)),((121 119 34,134 111 29,129 124 21,121 119 34)),((100 116 43,88 112 43,100 105 48,100 116 43)),((75 105 40,87 98 48,88 112 43,75 105 40)),((100 90 50,100 105 48,87 98 48,100 90 50)),((88 112 43,87 98 48,100 105 48,88 112 43)),((57 90 26,64 83 34,64 97 34,57 90 26)),((75 75 40,74 90 43,64 83 34,75 75 40)),((75 105 40,64 97 34,74 90 43,75 105 40)),((64 83 34,74 90 43,64 97 34,64 83 34)),((100 64 43,100 75 48,88 68 43,100 64 43)),((100 90 50,87 82 48,100 75 48,100 90 50)),((75 75 40,88 68 43,87 82 48,75 75 40)),((100 75 48,87 82 48,88 68 43,100 75 48)),((75 105 40,74 90 43,87 98 48,75 105 40)),((75 75 40,87 82 48,74 90 43,75 75 40)),((100 90 50,87 98 48,87 82 48,100 90 50)),((74 90 43,87 82 48,87 98 48,74 90 43)),((57 90 26,52 90 15,57 78 22,57 90 26)),((50 90 0,52 77 8,52 90 15,50 90 0)),((60 65 15,57 78 22,52 77 8,60 65 15)),((52 90 15,52 77 8,57 78 22,52 90 15)),((57 90 -26,57 78 -22,52 90 -15,57 90 -26)),((60 65 -15,52 77 -8,57 78 -22,60 65 -15)),((50 90 0,52 90 -15,52 77 -8,50 90 0)),((57 78 -22,52 77 -8,52 90 -15,57 78 -22)),((74 47 0,66 54 7,66 54 -7,74 47 0)),((60 65 15,57 64 0,66 54 7,60 65 15)),((60 65 -15,66 54 -7,57 64 0,60 65 -15)),((66 54 7,57 64 0,66 54 -7,66 54 7)),((50 90 0,52 77 -8,52 77 8,50 90 0)),((60 65 -15,57 64 0,52 77 -8,60 65 -15)),((60 65 15,52 77 8,57 64 0,60 65 15)),((52 77 -8,57 64 0,52 77 8,52 77 -8)),((57 90 -26,64 97 -34,64 83 -34,57 90 -26)),((75 105 -40,74 90 -43,64 97 -34,75 105 -40)),((75 75 -40,64 83 -34,74 90 -43,75 75 -40)),((64 97 -34,74 90 -43,64 83 -34,64 97 -34)),((100 116 -43,100 105 -48,88 112 -43,100 116 -43)),((100 90 -50,87 98 -48,100 105 -48,100 90 -50)),((75 105 -40,88 112 -43,87 98 -48,75 105 -40)),((100 105 -48,87 98 -48,88 112 -43,100 105 -48)),((100 64 -43,88 68 -43,100 75 -48,100 64 -43)),((75 75 -40,87 82 -48,88 68 -43,75 75 -40)),((100 90 -50,100 75 -48,87 82 -48,100 90 -50)),((88 68 -43,87 82 -48,100 75 -48,88 68 -43)),((75 105 -40,87 98 -48,74 90 -43,75 105 -40)),((100 90 -50,87 82 -48,87 98 -48,100 90 -50)),((75 75 -40,74 90 -43,87 82 -48,75 75 -40)),((87 98 -48,87 82 -48,74 90 -43,87 98 -48)),((100 116 -43,107 124 -36,112 112 -43,100 116 -43)),((115 130 -25,121 119 -34,107 124 -36,115 130 -25)),((125 105 -40,112 112 -43,121 119 -34,125 105 -40)),((107 124 -36,121 119 -34,112 112 -43,107 124 -36)),((126 133 0,134 126 -7,122 133 -12,126 133 0)),((140 115 -15,129 124 -21,134 126 -7,140 115 -15)),((115 130 -25,122 133 -12,129 124 -21,115 130 -25)),((134 126 -7,129 124 -21,122 133 -12,134 126 -7)),((143 90 -26,136 97 -34,143 102 -22,143 90 -26)),((125 105 -40,134 111 -29,136 97 -34,125 105 -40)),((140 115 -15,143 102 -22,134 111 -29,140 115 -15)),((136 97 -34,134 111 -29,143 102 -22,136 97 -34)),((115 130 -25,129 124 -21,121 119 -34,115 130 -25)),((140 115 -15,134 111 -29,129 124 -21,140 115 -15)),((125 105 -40,121 119 -34,134 111 -29,125 105 -40)),((129 124 -21,134 111 -29,121 119 -34,129 124 -21)),((126 47 0,134 54 7,122 47 12,126 47 0)),((140 65 15,129 56 21,134 54 7,140 65 15)),((115 50 25,122 47 12,129 56 21,115 50 25)),((134 54 7,129 56 21,122 47 12,134 54 7)),((143 90 26,136 83 34,143 78 22,143 90 26)),((125 75 40,134 69 29,136 83 34,125 75 40)),((140 65 15,143 78 22,134 69 29,140 65 15)),((136 83 34,134 69 29,143 78 22,136 83 34)),((100 64 43,107 56 36,112 68 43,100 64 43)),((115 50 25,121 61 34,107 56 36,115 50 25)),((125 75 40,112 68 43,121 61 34,125 75 40)),((107 56 36,121 61 34,112 68 43,107 56 36)),((140 65 15,134 69 29,129 56 21,140 65 15)),((125 75 40,121 61 34,134 69 29,125 75 40)),((115 50 25,129 56 21,121 61 34,115 50 25)),((134 69 29,121 61 34,129 56 21,134 69 29)),((126 47 0,122 47 12,115 42 0,126 47 0)),((115 50 25,108 42 13,122 47 12,115 50 25)),((100 40 0,115 42 0,108 42 13,100 40 0)),((122 47 12,108 42 13,115 42 0,122 47 12)),((100 64 43,93 56 36,107 56 36,100 64 43)),((85 50 25,100 47 26,93 56 36,85 50 25)),((115 50 25,107 56 36,100 47 26,115 50 25)),((93 56 36,100 47 26,107 56 36,93 56 36)),((74 47 0,85 42 0,78 47 12,74 47 0)),((100 40 0,92 42 13,85 42 0,100 40 0)),((85 50 25,78 47 12,92 42 13,85 50 25)),((85 42 0,92 42 13,78 47 12,85 42 0)),((115 50 25,100 47 26,108 42 13,115 50 25)),((85 50 25,92 42 13,100 47 26,85 50 25)),((100 40 0,108 42 13,92 42 13,100 40 0)),((100 47 26,92 42 13,108 42 13,100 47 26)),((126 47 0,115 42 0,122 47 -12,126 47 0)),((100 40 0,108 42 -13,115 42 0,100 40 0)),((115 50 -25,122 47 -12,108 42 -13,115 50 -25)),((115 42 0,108 42 -13,122 47 -12,115 42 0)),((74 47 0,78 47 -12,85 42 0,74 47 0)),((85 50 -25,92 42 -13,78 47 -12,85 50 -25)),((100 40 0,85 42 0,92 42 -13,100 40 0)),((78 47 -12,92 42 -13,85 42 0,78 47 -12)),((100 64 -43,107 56 -36,93 56 -36,100 64 -43)),((115 50 -25,100 47 -26,107 56 -36,115 50 -25)),((85 50 -25,93 56 -36,100 47 -26,85 50 -25)),((107 56 -36,100 47 -26,93 56 -36,107 56 -36)),((100 40 0,92 42 -13,108 42 -13,100 40 0)),((85 50 -25,100 47 -26,92 42 -13,85 50 -25)),((115 50 -25,108 42 -13,100 47 -26,115 50 -25)),((92 42 -13,100 47 -26,108 42 -13,92 42 -13)),((126 47 0,122 47 -12,134 54 -7,126 47 0)),((115 50 -25,129 56 -21,122 47 -12,115 50 -25)),((140 65 -15,134 54 -7,129 56 -21,140 65 -15)),((122 47 -12,129 56 -21,134 54 -7,122 47 -12)),((100 64 -43,112 68 -43,107 56 -36,100 64 -43)),((125 75 -40,121 61 -34,112 68 -43,125 75 -40)),((115 50 -25,107 56 -36,121 61 -34,115 50 -25)),((112 68 -43,121 61 -34,107 56 -36,112 68 -43)),((143 90 -26,143 78 -22,136 83 -34,143 90 -26)),((140 65 -15,134 69 -29,143 78 -22,140 65 -15)),((125 75 -40,136 83 -34,134 69 -29,125 75 -40)),((143 78 -22,134 69 -29,136 83 -34,143 78 -22)),((115 50 -25,121 61 -34,129 56 -21,115 50 -25)),((125 75 -40,134 69 -29,121 61 -34,125 75 -40)),((140 65 -15,129 56 -21,134 69 -29,140 65 -15)),((121 61 -34,134 69 -29,129 56 -21,121 61 -34)),((126 47 0,134 54 -7,134 54 7,126 47 0)),((140 65 -15,143 64 0,134 54 -7,140 65 -15)),((140 65 15,134 54 7,143 64 0,140 65 15)),((134 54 -7,143 64 0,134 54 7,134 54 -7)),((143 90 -26,148 90 -15,143 78 -22,143 90 -26)),((150 90 0,148 77 -8,148 90 -15,150 90 0)),((140 65 -15,143 78 -22,148 77 -8,140 65 -15)),((148 90 -15,148 77 -8,143 78 -22,148 90 -15)),((143 90 26,143 78 22,148 90 15,143 90 26)),((140 65 15,148 77 8,143 78 22,140 65 15)),((150 90 0,148 90 15,148 77 8,150 90 0)),((143 78 22,148 77 8,148 90 15,143 78 22)),((140 65 -15,148 77 -8,143 64 0,140 65 -15)),((150 90 0,148 77 8,148 77 -8,150 90 0)),((140 65 15,143 64 0,148 77 8,140 65 15)),((148 77 -8,148 77 8,143 64 0,148 77 -8)),((100 64 43,112 68 43,100 75 48,100 64 43)),((125 75 40,113 82 48,112 68 43,125 75 40)),((100 90 50,100 75 48,113 82 48,100 90 50)),((112 68 43,113 82 48,100 75 48,112 68 43)),((143 90 26,136 97 34,136 83 34,143 90 26)),((125 105 40,126 90 43,136 97 34,125 105 40)),((125 75 40,136 83 34,126 90 43,125 75 40)),((136 97 34,126 90 43,136 83 34,136 97 34)),((100 116 43,100 105 48,112 112 43,100 116 43)),((100 90 50,113 98 48,100 105 48,100 90 50)),((125 105 40,112 112 43,113 98 48,125 105 40)),((100 105 48,113 98 48,112 112 43,100 105 48)),((125 75 40,126 90 43,113 82 48,125 75 40)),((125 105 40,113 98 48,126 90 43,125 105 40)),((100 90 50,113 82 48,113 98 48,100 90 50)),((126 90 43,113 98 48,113 82 48,126 90 43)),((74 47 0,78 47 12,66 54 7,74 47 0)),((85 50 25,71 56 21,78 47 12,85 50 25)),((60 65 15,66 54 7,71 56 21,60 65 15)),((78 47 12,71 56 21,66 54 7,78 47 12)),((100 64 43,88 68 43,93 56 36,100 64 43)),((75 75 40,79 61 34,88 68 43,75 75 40)),((85 50 25,93 56 36,79 61 34,85 50 25)),((88 68 43,79 61 34,93 56 36,88 68 43)),((57 90 26,57 78 22,64 83 34,57 90 26)),((60 65 15,66 69 29,57 78 22,60 65 15)),((75 75 40,64 83 34,66 69 29,75 75 40)),((57 78 22,66 69 29,64 83 34,57 78 22)),((85 50 25,79 61 34,71 56 21,85 50 25)),((75 75 40,66 69 29,79 61 34,75 75 40)),((60 65 15,71 56 21,66 69 29,60 65 15)),((79 61 34,66 69 29,71 56 21,79 61 34)),((100 64 -43,93 56 -36,88 68 -43,100 64 -43)),((85 50 -25,79 61 -34,93 56 -36,85 50 -25)),((75 75 -40,88 68 -43,79 61 -34,75 75 -40)),((93 56 -36,79 61 -34,88 68 -43,93 56 -36)),((74 47 0,66 54 -7,78 47 -12,74 47 0)),((60 65 -15,71 56 -21,66 54 -7,60 65 -15)),((85 50 -25,78 47 -12,71 56 -21,85 50 -25)),((66 54 -7,71 56 -21,78 47 -12,66 54 -7)),((57 90 -26,64 83 -34,57 78 -22,57 90 -26)),((75 75 -40,66 69 -29,64 83 -34,75 75 -40)),((60 65 -15,57 78 -22,66 69 -29,60 65 -15)),((64 83 -34,66 69 -29,57 78 -22,64 83 -34)),((85 50 -25,71 56 -21,79 61 -34,85 50 -25)),((60 65 -15,66 69 -29,71 56 -21,60 65 -15)),((75 75 -40,79 61 -34,66 69 -29,75 75 -40)),((71 56 -21,66 69 -29,79 61 -34,71 56 -21)),((143 90 -26,136 83 -34,136 97 -34,143 90 -26)),((125 75 -40,126 90 -43,136 83 -34,125 75 -40)),((125 105 -40,136 97 -34,126 90 -43,125 105 -40)),((136 83 -34,126 90 -43,136 97 -34,136 83 -34)),((100 64 -43,100 75 -48,112 68 -43,100 64 -43)),((100 90 -50,113 82 -48,100 75 -48,100 90 -50)),((125 75 -40,112 68 -43,113 82 -48,125 75 -40)),((100 75 -48,113 82 -48,112 68 -43,100 75 -48)),((100 116 -43,112 112 -43,100 105 -48,100 116 -43)),((125 105 -40,113 98 -48,112 112 -43,125 105 -40)),((100 90 -50,100 105 -48,113 98 -48,100 90 -50)),((112 112 -43,113 98 -48,100 105 -48,112 112 -43)),((125 75 -40,113 82 -48,126 90 -43,125 75 -40)),((100 90 -50,113 98 -48,113 82 -48,100 90 -50)),((125 105 -40,126 90 -43,113 98 -48,125 105 -40)),((113 82 -48,113 98 -48,126 90 -43,113 82 -48)),((143 90 26,148 90 15,143 102 22,143 90 26)),((150 90 0,148 103 8,148 90 15,150 90 0)),((140 115 15,143 102 22,148 103 8,140 115 15)),((148 90 15,148 103 8,143 102 22,148 90 15)),((143 90 -26,143 102 -22,148 90 -15,143 90 -26)),((140 115 -15,148 103 -8,143 102 -22,140 115 -15)),((150 90 0,148 90 -15,148 103 -8,150 90 0)),((143 102 -22,148 103 -8,148 90 -15,143 102 -22)),((126 133 0,134 126 7,134 126 -7,126 133 0)),((140 115 15,143 116 0,134 126 7,140 115 15)),((140 115 -15,134 126 -7,143 116 0,140 115 -15)),((134 126 7,143 116 0,134 126 -7,134 126 7)),((150 90 0,148 103 -8,148 103 8,150 90 0)),((140 115 -15,143 116 0,148 103 -8,140 115 -15)),((140 115 15,148 103 8,143 116 0,140 115 15)),((148 103 -8,143 116 0,148 103 8,148 103 -8)))
A coarser rounded point buffer using 5 segments.
SELECT
'POINT(100 90)'::geometry AS input_geometry,
CG_3DBuffer('POINT(100 90)'::geometry, 50, 5, 0) AS buffer;POINT(100 90) | POLYHEDRALSURFACE Z (((74 133 0,60 115 15,85 130 25,74 133 0)),((57 90 26,75 105 40,60 115 15,57 90 26)),((100 116 43,85 130 25,75 105 40,100 116 43)),((60 115 15,75 105 40,85 130 25,60 115 15)),((74 133 0,85 130 25,100 140 0,74 133 0)),((100 116 43,115 130 25,85 130 25,100 116 43)),((126 133 0,100 140 0,115 130 25,126 133 0)),((85 130 25,115 130 25,100 140 0,85 130 25)),((74 133 0,100 140 0,85 130 -25,74 133 0)),((126 133 0,115 130 -25,100 140 0,126 133 0)),((100 116 -43,85 130 -25,115 130 -25,100 116 -43)),((100 140 0,115 130 -25,85 130 -25,100 140 0)),((74 133 0,85 130 -25,60 115 -15,74 133 0)),((100 116 -43,75 105 -40,85 130 -25,100 116 -43)),((57 90 -26,60 115 -15,75 105 -40,57 90 -26)),((85 130 -25,75 105 -40,60 115 -15,85 130 -25)),((74 133 0,60 115 -15,60 115 15,74 133 0)),((57 90 -26,50 90 0,60 115 -15,57 90 -26)),((57 90 26,60 115 15,50 90 0,57 90 26)),((60 115 -15,50 90 0,60 115 15,60 115 -15)),((126 133 0,115 130 25,140 115 15,126 133 0)),((100 116 43,125 105 40,115 130 25,100 116 43)),((143 90 26,140 115 15,125 105 40,143 90 26)),((115 130 25,125 105 40,140 115 15,115 130 25)),((100 116 43,75 105 40,100 90 50,100 116 43)),((57 90 26,75 75 40,75 105 40,57 90 26)),((100 64 43,100 90 50,75 75 40,100 64 43)),((75 105 40,75 75 40,100 90 50,75 105 40)),((57 90 26,50 90 0,60 65 15,57 90 26)),((57 90 -26,60 65 -15,50 90 0,57 90 -26)),((74 47 0,60 65 15,60 65 -15,74 47 0)),((50 90 0,60 65 -15,60 65 15,50 90 0)),((57 90 -26,75 105 -40,75 75 -40,57 90 -26)),((100 116 -43,100 90 -50,75 105 -40,100 116 -43)),((100 64 -43,75 75 -40,100 90 -50,100 64 -43)),((75 105 -40,100 90 -50,75 75 -40,75 105 -40)),((100 116 -43,115 130 -25,125 105 -40,100 116 -43)),((126 133 0,140 115 -15,115 130 -25,126 133 0)),((143 90 -26,125 105 -40,140 115 -15,143 90 -26)),((115 130 -25,140 115 -15,125 105 -40,115 130 -25)),((126 47 0,140 65 15,115 50 25,126 47 0)),((143 90 26,125 75 40,140 65 15,143 90 26)),((100 64 43,115 50 25,125 75 40,100 64 43)),((140 65 15,125 75 40,115 50 25,140 65 15)),((126 47 0,115 50 25,100 40 0,126 47 0)),((100 64 43,85 50 25,115 50 25,100 64 43)),((74 47 0,100 40 0,85 50 25,74 47 0)),((115 50 25,85 50 25,100 40 0,115 50 25)),((126 47 0,100 40 0,115 50 -25,126 47 0)),((74 47 0,85 50 -25,100 40 0,74 47 0)),((100 64 -43,115 50 -25,85 50 -25,100 64 -43)),((100 40 0,85 50 -25,115 50 -25,100 40 0)),((126 47 0,115 50 -25,140 65 -15,126 47 0)),((100 64 -43,125 75 -40,115 50 -25,100 64 -43)),((143 90 -26,140 65 -15,125 75 -40,143 90 -26)),((115 50 -25,125 75 -40,140 65 -15,115 50 -25)),((126 47 0,140 65 -15,140 65 15,126 47 0)),((143 90 -26,150 90 0,140 65 -15,143 90 -26)),((143 90 26,140 65 15,150 90 0,143 90 26)),((140 65 -15,150 90 0,140 65 15,140 65 -15)),((100 64 43,125 75 40,100 90 50,100 64 43)),((143 90 26,125 105 40,125 75 40,143 90 26)),((100 116 43,100 90 50,125 105 40,100 116 43)),((125 75 40,125 105 40,100 90 50,125 75 40)),((74 47 0,85 50 25,60 65 15,74 47 0)),((100 64 43,75 75 40,85 50 25,100 64 43)),((57 90 26,60 65 15,75 75 40,57 90 26)),((85 50 25,75 75 40,60 65 15,85 50 25)),((100 64 -43,85 50 -25,75 75 -40,100 64 -43)),((74 47 0,60 65 -15,85 50 -25,74 47 0)),((57 90 -26,75 75 -40,60 65 -15,57 90 -26)),((85 50 -25,60 65 -15,75 75 -40,85 50 -25)),((143 90 -26,125 75 -40,125 105 -40,143 90 -26)),((100 64 -43,100 90 -50,125 75 -40,100 64 -43)),((100 116 -43,125 105 -40,100 90 -50,100 116 -43)),((125 75 -40,100 90 -50,125 105 -40,125 75 -40)),((143 90 26,150 90 0,140 115 15,143 90 26)),((143 90 -26,140 115 -15,150 90 0,143 90 -26)),((126 133 0,140 115 15,140 115 -15,126 133 0)),((150 90 0,140 115 -15,140 115 15,150 90 0)))
A rounded buffer around a line using 32 segments.
SELECT
'LINESTRING(50 50,150 150,150 50)'::geometry AS input_geometry,
CG_3DBuffer('LINESTRING(50 50,150 150,150 50)'::geometry, 10, 32, 0) AS buffer;LINESTRING(50 50,150 150,150 50) | POLYHEDRALSURFACE Z (((40 50 3,40 50 0,40 47 2,40 50 3)),((40 47 2,40 50 0,40 47 -2,40 47 2)),((40 47 -2,40 50 0,40 50 -3,40 47 -2)),((40 50 -3,40 50 0,40 53 -2,40 50 -3)),((40 53 -2,40 50 0,40 53 2,40 53 -2)),((40 53 2,40 50 0,40 50 3,40 53 2)),((40 53 2,40 50 3,41 52 4,40 53 2)),((41 52 4,40 50 3,41 50 5,41 52 4)),((41 50 5,40 50 3,41 48 4,41 50 5)),((41 48 4,40 50 3,40 47 2,41 48 4)),((40 47 2,40 47 -2,41 45 0,40 47 2)),((41 48 4,40 47 2,42 45 3,41 48 4)),((42 45 3,40 47 2,41 45 0,42 45 3)),((41 45 0,40 47 -2,42 45 -3,41 45 0)),((42 45 -3,40 47 -2,41 48 -4,42 45 -3)),((40 47 -2,40 50 -3,41 48 -4,40 47 -2)),((41 48 -4,40 50 -3,41 50 -5,41 48 -4)),((41 50 -5,40 50 -3,41 52 -4,41 50 -5)),((41 52 -4,40 50 -3,40 53 -2,41 52 -4)),((41 55 0,40 53 -2,40 53 2,41 55 0)),((41 52 -4,40 53 -2,42 55 -3,41 52 -4)),((42 55 -3,40 53 -2,41 55 0,42 55 -3)),((41 55 0,40 53 2,42 55 3,41 55 0)),((42 55 3,40 53 2,41 52 4,42 55 3)),((42 55 3,41 52 4,43 54 6,42 55 3)),((43 54 6,41 52 4,43 51 7,43 54 6)),((43 51 7,41 52 4,41 50 5,43 51 7)),((43 51 7,41 50 5,43 49 7,43 51 7)),((41 50 5,41 48 4,43 49 7,41 50 5)),((43 49 7,41 48 4,43 46 6,43 49 7)),((43 46 6,41 48 4,42 45 3,43 46 6)),((42 45 3,41 45 0,43 43 1,42 45 3)),((43 43 1,41 45 0,43 43 -1,43 43 1)),((43 43 -1,41 45 0,42 45 -3,43 43 -1)),((43 46 6,42 45 3,44 43 4,43 46 6)),((44 43 4,42 45 3,43 43 1,44 43 4)),((44 43 -4,42 45 -3,43 46 -6,44 43 -4)),((42 45 -3,41 48 -4,43 46 -6,42 45 -3)),((43 43 -1,42 45 -3,44 43 -4,43 43 -1)),((43 46 -6,41 48 -4,43 49 -7,43 46 -6)),((43 49 -7,41 48 -4,41 50 -5,43 49 -7)),((43 49 -7,41 50 -5,43 51 -7,43 49 -7)),((41 50 -5,41 52 -4,43 51 -7,41 50 -5)),((43 51 -7,41 52 -4,43 54 -6,43 51 -7)),((43 54 -6,41 52 -4,42 55 -3,43 54 -6)),((42 55 -3,41 55 0,43 57 -1,42 55 -3)),((43 57 -1,41 55 0,43 57 1,43 57 -1)),((43 57 1,41 55 0,42 55 3,43 57 1)),((43 54 -6,42 55 -3,44 57 -4,43 54 -6)),((44 57 -4,42 55 -3,43 57 -1,44 57 -4)),((43 57 1,42 55 3,44 57 4,43 57 1)),((44 57 4,42 55 3,43 54 6,44 57 4)),((43 54 6,46 56 7,44 57 4,43 54 6)),((44 57 4,46 56 7,146 156 7,44 57 4)),((44 57 4,146 156 7,144 157 4,44 57 4)),((46 56 7,43 54 6,45 53 8,46 56 7)),((43 54 6,43 51 7,45 53 8,43 54 6)),((45 53 8,43 51 7,45 50 9,45 53 8)),((43 51 7,43 49 7,45 50 9,43 51 7)),((45 50 9,43 49 7,45 47 8,45 50 9)),((45 47 8,43 49 7,43 46 6,45 47 8)),((45 47 8,43 46 6,46 44 7,45 47 8)),((46 44 7,43 46 6,44 43 4,46 44 7)),((43 43 1,43 43 -1,45 41 0,43 43 1)),((44 43 4,43 43 1,46 41 2,44 43 4)),((46 41 2,43 43 1,45 41 0,46 41 2)),((45 41 0,43 43 -1,46 41 -2,45 41 0)),((46 41 -2,43 43 -1,44 43 -4,46 41 -2)),((46 44 7,44 43 4,47 42 5,46 44 7)),((47 42 5,44 43 4,46 41 2,47 42 5)),((47 42 -5,44 43 -4,46 44 -7,47 42 -5)),((44 43 -4,43 46 -6,46 44 -7,44 43 -4)),((46 41 -2,44 43 -4,47 42 -5,46 41 -2)),((46 44 -7,43 46 -6,45 47 -8,46 44 -7)),((43 46 -6,43 49 -7,45 47 -8,43 46 -6)),((45 47 -8,43 49 -7,45 50 -9,45 47 -8)),((45 50 -9,43 49 -7,43 51 -7,45 50 -9)),((45 50 -9,43 51 -7,45 53 -8,45 50 -9)),((45 53 -8,43 51 -7,43 54 -6,45 53 -8)),((45 53 -8,43 54 -6,46 56 -7,45 53 -8)),((43 54 -6,44 57 -4,46 56 -7,43 54 -6)),((46 56 -7,44 57 -4,144 157 -4,46 56 -7)),((46 56 -7,144 157 -4,146 156 -7,46 56 -7)),((43 57 -1,43 57 1,143 157 -1,43 57 -1)),((143 157 -1,43 57 1,143 157 1,143 157 -1)),((43 57 -1,143 157 -1,44 57 -4,43 57 -1)),((44 57 -4,143 157 -1,144 157 -4,44 57 -4)),((43 57 1,44 57 4,143 157 1,43 57 1)),((143 157 1,44 57 4,144 157 4,143 157 1)),((146 159 2,143 157 1,144 157 4,146 159 2)),((146 159 2,144 157 4,147 158 5,146 159 2)),((147 158 5,144 157 4,146 156 7,147 158 5)),((46 56 7,45 53 8,145 153 8,46 56 7)),((146 156 7,46 56 7,145 153 8,146 156 7)),((147 158 5,146 156 7,149 157 7,147 158 5)),((149 157 7,146 156 7,148 154 9,149 157 7)),((146 156 7,145 153 8,148 154 9,146 156 7)),((145 153 8,45 53 8,48 54 9,145 153 8)),((148 154 9,145 153 8,48 54 9,148 154 9)),((48 54 9,45 53 8,47 52 10,48 54 9)),((45 53 8,45 50 9,47 52 10,45 53 8)),((47 52 10,45 50 9,47 48 10,47 52 10)),((47 48 10,45 50 9,45 47 8,47 48 10)),((47 48 10,45 47 8,48 46 9,47 48 10)),((48 46 9,45 47 8,46 44 7,48 46 9)),((48 46 9,46 44 7,49 43 7,48 46 9)),((49 43 7,46 44 7,47 42 5,49 43 7)),((46 41 2,45 41 0,47 40 0,46 41 2)),((47 40 0,45 41 0,46 41 -2,47 40 0)),((47 42 5,46 41 2,48 40 3,47 42 5)),((48 40 3,46 41 2,47 40 0,48 40 3)),((48 40 -3,46 41 -2,47 42 -5,48 40 -3)),((47 40 0,46 41 -2,48 40 -3,47 40 0)),((49 43 7,47 42 5,50 41 5,49 43 7)),((50 41 5,47 42 5,48 40 3,50 41 5)),((50 41 -5,47 42 -5,49 43 -7,50 41 -5)),((47 42 -5,46 44 -7,49 43 -7,47 42 -5)),((48 40 -3,47 42 -5,50 41 -5,48 40 -3)),((49 43 -7,46 44 -7,48 46 -9,49 43 -7)),((46 44 -7,45 47 -8,48 46 -9,46 44 -7)),((48 46 -9,45 47 -8,47 48 -10,48 46 -9)),((45 47 -8,45 50 -9,47 48 -10,45 47 -8)),((47 48 -10,45 50 -9,47 52 -10,47 48 -10)),((47 52 -10,45 50 -9,45 53 -8,47 52 -10)),((47 52 -10,45 53 -8,48 54 -9,47 52 -10)),((45 53 -8,145 153 -8,48 54 -9,45 53 -8)),((48 54 -9,145 153 -8,148 154 -9,48 54 -9)),((45 53 -8,46 56 -7,145 153 -8,45 53 -8)),((145 153 -8,46 56 -7,146 156 -7,145 153 -8)),((148 154 -9,145 153 -8,146 156 -7,148 154 -9)),((148 154 -9,146 156 -7,149 157 -7,148 154 -9)),((149 157 -7,146 156 -7,147 158 -5,149 157 -7)),((146 156 -7,144 157 -4,147 158 -5,146 156 -7)),((147 158 -5,144 157 -4,146 159 -2,147 158 -5)),((144 157 -4,143 157 -1,146 159 -2,144 157 -4)),((146 159 -2,143 157 -1,145 159 0,146 159 -2)),((145 159 0,143 157 -1,143 157 1,145 159 0)),((145 159 0,143 157 1,146 159 2,145 159 0)),((147 160 0,145 159 0,146 159 2,147 160 0)),((147 160 0,146 159 2,148 160 3,147 160 0)),((148 160 3,146 159 2,147 158 5,148 160 3)),((148 160 3,147 158 5,150 159 5,148 160 3)),((150 159 5,147 158 5,149 157 7,150 159 5)),((150 159 5,149 157 7,151 157 7,150 159 5)),((151 157 7,149 157 7,150 155 9,151 157 7)),((149 157 7,148 154 9,150 155 9,149 157 7)),((48 54 9,47 52 10,147 152 10,48 54 9)),((148 154 9,48 54 9,147 152 10,148 154 9)),((150 155 9,148 154 9,150 153 10,150 155 9)),((148 154 9,147 152 10,150 153 10,148 154 9)),((147 152 10,47 52 10,50 50 10,147 152 10)),((150 150 10,147 152 10,50 50 10,150 150 10)),((47 52 10,47 48 10,50 50 10,47 52 10)),((50 50 10,47 48 10,50 47 10,50 50 10)),((50 47 10,47 48 10,48 46 9,50 47 10)),((50 47 10,48 46 9,50 45 9,50 47 10)),((50 45 9,48 46 9,49 43 7,50 45 9)),((50 45 9,49 43 7,51 43 7,50 45 9)),((51 43 7,49 43 7,50 41 5,51 43 7)),((48 40 3,47 40 0,50 40 0,48 40 3)),((50 40 0,47 40 0,48 40 -3,50 40 0)),((50 41 5,48 40 3,52 40 3,50 41 5)),((52 40 3,48 40 3,50 40 0,52 40 3)),((50 40 0,48 40 -3,52 40 -3,50 40 0)),((52 40 -3,48 40 -3,50 41 -5,52 40 -3)),((51 43 7,50 41 5,53 42 5,51 43 7)),((53 42 5,50 41 5,52 40 3,53 42 5)),((52 40 -3,50 41 -5,53 42 -5,52 40 -3)),((53 42 -5,50 41 -5,51 43 -7,53 42 -5)),((50 41 -5,49 43 -7,51 43 -7,50 41 -5)),((51 43 -7,49 43 -7,50 45 -9,51 43 -7)),((49 43 -7,48 46 -9,50 45 -9,49 43 -7)),((50 45 -9,48 46 -9,50 47 -10,50 45 -9)),((48 46 -9,47 48 -10,50 47 -10,48 46 -9)),((50 47 -10,47 48 -10,50 50 -10,50 47 -10)),((50 50 -10,47 48 -10,47 52 -10,50 50 -10)),((47 52 -10,147 152 -10,50 50 -10,47 52 -10)),((50 50 -10,147 152 -10,150 150 -10,50 50 -10)),((47 52 -10,48 54 -9,147 152 -10,47 52 -10)),((147 152 -10,48 54 -9,148 154 -9,147 152 -10)),((150 153 -10,147 152 -10,148 154 -9,150 153 -10)),((150 153 -10,148 154 -9,150 155 -9,150 153 -10)),((150 155 -9,148 154 -9,149 157 -7,150 155 -9)),((150 155 -9,149 157 -7,151 157 -7,150 155 -9)),((151 157 -7,149 157 -7,150 159 -5,151 157 -7)),((149 157 -7,147 158 -5,150 159 -5,149 157 -7)),((150 159 -5,147 158 -5,148 160 -3,150 159 -5)),((147 158 -5,146 159 -2,148 160 -3,147 158 -5)),((148 160 -3,146 159 -2,147 160 0,148 160 -3)),((146 159 -2,145 159 0,147 160 0,146 159 -2)),((148 160 -3,147 160 0,150 160 0,148 160 -3)),((150 160 0,147 160 0,148 160 3,150 160 0)),((150 160 0,148 160 3,152 160 3,150 160 0)),((152 160 3,148 160 3,150 159 5,152 160 3)),((152 160 3,150 159 5,153 158 5,152 160 3)),((153 158 5,150 159 5,151 157 7,153 158 5)),((153 158 5,151 157 7,154 156 7,153 158 5)),((154 156 7,151 157 7,152 154 9,154 156 7)),((151 157 7,150 155 9,152 154 9,151 157 7)),((150 155 9,150 153 10,152 154 9,150 155 9)),((150 153 10,147 152 10,150 150 10,150 153 10)),((152 154 9,150 153 10,153 152 10,152 154 9)),((150 153 10,150 150 10,153 152 10,150 153 10)),((150 150 10,150 50 10,153 48 10,150 150 10)),((153 152 10,150 150 10,153 48 10,153 152 10)),((147 143 10,147 48 10,150 50 10,147 143 10)),((150 150 10,147 143 10,150 50 10,150 150 10)),((150 150 10,50 50 10,53 48 10,150 150 10)),((147 143 10,150 150 10,53 48 10,147 143 10)),((50 50 10,50 47 10,53 48 10,50 50 10)),((53 48 10,50 47 10,52 46 9,53 48 10)),((50 47 10,50 45 9,52 46 9,50 47 10)),((52 46 9,50 45 9,51 43 7,52 46 9)),((52 46 9,51 43 7,54 44 7,52 46 9)),((54 44 7,51 43 7,53 42 5,54 44 7)),((52 40 3,50 40 0,53 40 0,52 40 3)),((53 40 0,50 40 0,52 40 -3,53 40 0)),((53 42 5,52 40 3,54 41 2,53 42 5)),((54 41 2,52 40 3,53 40 0,54 41 2)),((53 40 0,52 40 -3,54 41 -2,53 40 0)),((54 41 -2,52 40 -3,53 42 -5,54 41 -2)),((54 44 7,53 42 5,56 43 4,54 44 7)),((56 43 4,53 42 5,54 41 2,56 43 4)),((54 41 -2,53 42 -5,56 43 -4,54 41 -2)),((56 43 -4,53 42 -5,54 44 -7,56 43 -4)),((53 42 -5,51 43 -7,54 44 -7,53 42 -5)),((54 44 -7,51 43 -7,52 46 -9,54 44 -7)),((51 43 -7,50 45 -9,52 46 -9,51 43 -7)),((52 46 -9,50 45 -9,50 47 -10,52 46 -9)),((52 46 -9,50 47 -10,53 48 -10,52 46 -9)),((53 48 -10,50 47 -10,50 50 -10,53 48 -10)),((50 50 -10,150 150 -10,53 48 -10,50 50 -10)),((53 48 -10,150 150 -10,147 143 -10,53 48 -10)),((147 48 -10,147 143 -10,150 50 -10,147 48 -10)),((150 50 -10,147 143 -10,150 150 -10,150 50 -10)),((150 50 -10,150 150 -10,153 48 -10,150 50 -10)),((153 48 -10,150 150 -10,153 152 -10,153 48 -10)),((153 152 -10,150 150 -10,150 153 -10,153 152 -10)),((150 150 -10,147 152 -10,150 153 -10,150 150 -10)),((153 152 -10,150 153 -10,152 154 -9,153 152 -10)),((152 154 -9,150 153 -10,150 155 -9,152 154 -9)),((152 154 -9,150 155 -9,151 157 -7,152 154 -9)),((152 154 -9,151 157 -7,154 156 -7,152 154 -9)),((154 156 -7,151 157 -7,153 158 -5,154 156 -7)),((151 157 -7,150 159 -5,153 158 -5,151 157 -7)),((153 158 -5,150 159 -5,152 160 -3,153 158 -5)),((150 159 -5,148 160 -3,152 160 -3,150 159 -5)),((152 160 -3,148 160 -3,150 160 0,152 160 -3)),((152 160 -3,150 160 0,153 160 0,152 160 -3)),((153 160 0,150 160 0,152 160 3,153 160 0)),((153 160 0,152 160 3,154 159 2,153 160 0)),((154 159 2,152 160 3,153 158 5,154 159 2)),((154 159 2,153 158 5,156 157 4,154 159 2)),((156 157 4,153 158 5,154 156 7,156 157 4)),((156 157 4,154 156 7,157 154 6,156 157 4)),((157 154 6,154 156 7,155 153 8,157 154 6)),((154 156 7,152 154 9,155 153 8,154 156 7)),((155 153 8,152 154 9,153 152 10,155 153 8)),((155 153 8,153 152 10,155 150 9,155 153 8)),((153 152 10,153 48 10,155 50 9,153 152 10)),((155 150 9,153 152 10,155 50 9,155 150 9)),((150 50 10,150 47 10,153 48 10,150 50 10)),((155 50 9,153 48 10,155 47 8,155 50 9)),((153 48 10,152 46 9,155 47 8,153 48 10)),((153 48 10,150 47 10,152 46 9,153 48 10)),((150 50 10,147 48 10,150 47 10,150 50 10)),((145 138 9,145 50 9,147 48 10,145 138 9)),((145 138 9,145 138 9,147 48 10,145 138 9)),((147 143 10,145 138 9,147 48 10,147 143 10)),((53 48 10,52 46 9,145 138 9,53 48 10)),((147 143 10,53 48 10,145 138 9,147 143 10)),((147 48 10,145 50 9,145 47 8,147 48 10)),((150 47 10,147 48 10,148 46 9,150 47 10)),((147 48 10,145 47 8,148 46 9,147 48 10)),((145 138 9,52 46 9,55 47 8,145 138 9)),((145 138 9,145 138 9,55 47 8,145 138 9)),((144 136 8,145 138 9,55 47 8,144 136 8)),((55 47 8,52 46 9,54 44 7,55 47 8)),((55 47 8,54 44 7,143 133 7,55 47 8)),((144 136 8,55 47 8,143 133 7,144 136 8)),((143 133 7,54 44 7,56 43 4,143 133 7)),((143 133 7,143 133 7,56 43 4,143 133 7)),((141 128 4,141 130 5,56 43 4,141 128 4)),((141 130 5,143 133 7,56 43 4,141 130 5)),((54 41 2,53 40 0,55 41 0,54 41 2)),((55 41 0,53 40 0,54 41 -2,55 41 0)),((56 43 4,54 41 2,57 43 1,56 43 4)),((57 43 1,54 41 2,55 41 0,57 43 1)),((55 41 0,54 41 -2,57 43 -1,55 41 0)),((57 43 -1,54 41 -2,56 43 -4,57 43 -1)),((141 128 4,56 43 4,57 43 1,141 128 4)),((140 127 3,141 128 4,57 43 1,140 127 3)),((140 126 1,140 127 3,57 43 1,140 126 1)),((57 43 -1,56 43 -4,141 128 -4,57 43 -1)),((140 126 -1,57 43 -1,140 127 -3,140 126 -1)),((140 127 -3,57 43 -1,141 128 -4,140 127 -3)),((56 43 -4,54 44 -7,143 133 -7,56 43 -4)),((141 130 -5,56 43 -4,143 133 -7,141 130 -5)),((143 133 -7,56 43 -4,143 133 -7,143 133 -7)),((141 128 -4,56 43 -4,141 130 -5,141 128 -4)),((54 44 -7,55 47 -8,143 133 -7,54 44 -7)),((143 133 -7,55 47 -8,144 136 -8,143 133 -7)),((54 44 -7,52 46 -9,55 47 -8,54 44 -7)),((52 46 -9,145 138 -9,55 47 -8,52 46 -9)),((55 47 -8,145 138 -9,145 138 -9,55 47 -8)),((55 47 -8,145 138 -9,144 136 -8,55 47 -8)),((52 46 -9,53 48 -10,145 138 -9,52 46 -9)),((145 138 -9,53 48 -10,147 143 -10,145 138 -9)),((145 50 -9,145 138 -9,147 48 -10,145 50 -9)),((147 48 -10,145 138 -9,145 138 -9,147 48 -10)),((147 48 -10,145 138 -9,147 143 -10,147 48 -10)),((150 47 -10,147 48 -10,150 50 -10,150 47 -10)),((153 48 -10,150 47 -10,150 50 -10,153 48 -10)),((145 47 -8,145 50 -9,147 48 -10,145 47 -8)),((148 46 -9,145 47 -8,147 48 -10,148 46 -9)),((148 46 -9,147 48 -10,150 47 -10,148 46 -9)),((155 47 -8,153 48 -10,155 50 -9,155 47 -8)),((153 48 -10,153 152 -10,155 50 -9,153 48 -10)),((155 50 -9,153 152 -10,155 150 -9,155 50 -9)),((152 46 -9,150 47 -10,153 48 -10,152 46 -9)),((155 47 -8,152 46 -9,153 48 -10,155 47 -8)),((155 150 -9,153 152 -10,155 153 -8,155 150 -9)),((153 152 -10,152 154 -9,155 153 -8,153 152 -10)),((155 153 -8,152 154 -9,154 156 -7,155 153 -8)),((155 153 -8,154 156 -7,157 154 -6,155 153 -8)),((157 154 -6,154 156 -7,156 157 -4,157 154 -6)),((154 156 -7,153 158 -5,156 157 -4,154 156 -7)),((156 157 -4,153 158 -5,154 159 -2,156 157 -4)),((153 158 -5,152 160 -3,154 159 -2,153 158 -5)),((154 159 -2,152 160 -3,153 160 0,154 159 -2)),((154 159 -2,153 160 0,155 159 0,154 159 -2)),((155 159 0,153 160 0,154 159 2,155 159 0)),((155 159 0,154 159 2,157 157 1,155 159 0)),((157 157 1,154 159 2,156 157 4,157 157 1)),((157 157 1,156 157 4,158 155 3,157 157 1)),((158 155 3,156 157 4,157 154 6,158 155 3)),((158 155 3,157 154 6,159 152 4,158 155 3)),((159 152 4,157 154 6,157 151 7,159 152 4)),((157 154 6,155 153 8,157 151 7,157 154 6)),((157 151 7,155 153 8,155 150 9,157 151 7)),((155 150 9,155 50 9,157 49 7,155 150 9)),((157 151 7,155 150 9,157 49 7,157 151 7)),((155 50 9,155 47 8,157 49 7,155 50 9)),((150 47 10,150 45 9,152 46 9,150 47 10)),((150 47 10,148 46 9,150 45 9,150 47 10)),((157 49 7,155 47 8,157 46 6,157 49 7)),((155 47 8,154 44 7,157 46 6,155 47 8)),((155 47 8,152 46 9,154 44 7,155 47 8)),((152 46 9,151 43 7,154 44 7,152 46 9)),((152 46 9,150 45 9,151 43 7,152 46 9)),((143 133 7,143 49 7,145 50 9,143 133 7)),((143 133 7,143 133 7,145 50 9,143 133 7)),((145 138 9,144 136 8,145 50 9,145 138 9)),((144 136 8,143 133 7,145 50 9,144 136 8)),((145 50 9,143 49 7,145 47 8,145 50 9)),((145 47 8,143 49 7,143 46 6,145 47 8)),((148 46 9,145 47 8,146 44 7,148 46 9)),((145 47 8,143 46 6,146 44 7,145 47 8)),((150 45 9,148 46 9,149 43 7,150 45 9)),((148 46 9,146 44 7,149 43 7,148 46 9)),((141 50 5,143 49 7,141 130 5,141 50 5)),((141 130 5,143 49 7,143 133 7,141 130 5)),((140 50 3,141 50 5,140 127 3,140 50 3)),((141 128 4,141 50 5,141 130 5,141 128 4)),((140 127 3,141 50 5,141 128 4,140 127 3)),((57 43 1,55 41 0,57 43 -1,57 43 1)),((57 43 1,57 43 -1,140 126 -1,57 43 1)),((140 126 1,57 43 1,140 126 0,140 126 1)),((140 126 0,57 43 1,140 126 -1,140 126 0)),((140 50 0,140 50 3,140 126 0,140 50 0)),((140 126 1,140 50 3,140 127 3,140 126 1)),((140 126 0,140 50 3,140 126 1,140 126 0)),((140 50 0,140 126 0,140 50 -3,140 50 0)),((140 50 -3,140 126 0,140 126 -1,140 50 -3)),((140 50 -3,140 126 -1,140 127 -3,140 50 -3)),((140 50 -3,140 127 -3,141 50 -5,140 50 -3)),((141 50 -5,140 127 -3,141 128 -4,141 50 -5)),((141 50 -5,141 128 -4,141 130 -5,141 50 -5)),((141 50 -5,141 130 -5,143 49 -7,141 50 -5)),((143 49 -7,141 130 -5,143 133 -7,143 49 -7)),((143 49 -7,143 133 -7,145 50 -9,143 49 -7)),((145 50 -9,143 133 -7,143 133 -7,145 50 -9)),((145 50 -9,143 133 -7,144 136 -8,145 50 -9)),((144 136 -8,145 138 -9,145 50 -9,144 136 -8)),((145 47 -8,143 49 -7,145 50 -9,145 47 -8)),((150 45 -9,148 46 -9,150 47 -10,150 45 -9)),((152 46 -9,150 45 -9,150 47 -10,152 46 -9)),((143 46 -6,143 49 -7,145 47 -8,143 46 -6)),((146 44 -7,143 46 -6,145 47 -8,146 44 -7)),((146 44 -7,145 47 -8,148 46 -9,146 44 -7)),((149 43 -7,146 44 -7,148 46 -9,149 43 -7)),((149 43 -7,148 46 -9,150 45 -9,149 43 -7)),((157 46 -6,155 47 -8,157 49 -7,157 46 -6)),((157 49 -7,155 47 -8,155 50 -9,157 49 -7)),((154 44 -7,152 46 -9,155 47 -8,154 44 -7)),((157 46 -6,154 44 -7,155 47 -8,157 46 -6)),((155 50 -9,155 150 -9,157 49 -7,155 50 -9)),((157 49 -7,155 150 -9,157 151 -7,157 49 -7)),((155 150 -9,155 153 -8,157 151 -7,155 150 -9)),((151 43 -7,150 45 -9,152 46 -9,151 43 -7)),((154 44 -7,151 43 -7,152 46 -9,154 44 -7)),((157 151 -7,155 153 -8,157 154 -6,157 151 -7)),((157 151 -7,157 154 -6,159 152 -4,157 151 -7)),((159 152 -4,157 154 -6,158 155 -3,159 152 -4)),((157 154 -6,156 157 -4,158 155 -3,157 154 -6)),((158 155 -3,156 157 -4,157 157 -1,158 155 -3)),((156 157 -4,154 159 -2,157 157 -1,156 157 -4)),((157 157 -1,154 159 -2,155 159 0,157 157 -1)),((157 157 -1,155 159 0,157 157 1,157 157 -1)),((159 155 0,157 157 -1,157 157 1,159 155 0)),((159 155 0,157 157 1,158 155 3,159 155 0)),((159 155 0,158 155 3,160 153 2,159 155 0)),((160 153 2,158 155 3,159 152 4,160 153 2)),((160 153 2,159 152 4,160 150 3,160 153 2)),((159 152 4,159 150 5,160 150 3,159 152 4)),((159 152 4,157 151 7,159 150 5,159 152 4)),((157 151 7,157 49 7,159 50 5,157 151 7)),((159 150 5,157 151 7,159 50 5,159 150 5)),((159 50 5,157 49 7,159 48 4,159 50 5)),((157 49 7,157 46 6,159 48 4,157 49 7)),((150 45 9,149 43 7,151 43 7,150 45 9)),((159 48 4,157 46 6,158 45 3,159 48 4)),((157 46 6,156 43 4,158 45 3,157 46 6)),((157 46 6,154 44 7,156 43 4,157 46 6)),((154 44 7,153 42 5,156 43 4,154 44 7)),((154 44 7,151 43 7,153 42 5,154 44 7)),((151 43 7,149 43 7,150 41 5,151 43 7)),((151 43 7,150 41 5,153 42 5,151 43 7)),((141 50 5,141 48 4,143 49 7,141 50 5)),((143 49 7,141 48 4,143 46 6,143 49 7)),((143 46 6,141 48 4,142 45 3,143 46 6)),((146 44 7,143 46 6,144 43 4,146 44 7)),((143 46 6,142 45 3,144 43 4,143 46 6)),((149 43 7,146 44 7,147 42 5,149 43 7)),((146 44 7,144 43 4,147 42 5,146 44 7)),((149 43 7,147 42 5,150 41 5,149 43 7)),((141 50 5,140 50 3,141 48 4,141 50 5)),((140 50 3,140 50 0,140 47 2,140 50 3)),((141 48 4,140 50 3,140 47 2,141 48 4)),((140 47 2,140 50 0,140 47 -2,140 47 2)),((140 47 -2,140 50 0,140 50 -3,140 47 -2)),((141 48 -4,140 50 -3,141 50 -5,141 48 -4)),((140 47 -2,140 50 -3,141 48 -4,140 47 -2)),((143 49 -7,141 48 -4,141 50 -5,143 49 -7)),((143 46 -6,141 48 -4,143 49 -7,143 46 -6)),((151 43 -7,149 43 -7,150 45 -9,151 43 -7)),((142 45 -3,141 48 -4,143 46 -6,142 45 -3)),((144 43 -4,142 45 -3,143 46 -6,144 43 -4)),((144 43 -4,143 46 -6,146 44 -7,144 43 -4)),((147 42 -5,144 43 -4,146 44 -7,147 42 -5)),((147 42 -5,146 44 -7,149 43 -7,147 42 -5)),((150 41 -5,149 43 -7,151 43 -7,150 41 -5)),((150 41 -5,147 42 -5,149 43 -7,150 41 -5)),((158 45 -3,157 46 -6,159 48 -4,158 45 -3)),((159 48 -4,157 46 -6,157 49 -7,159 48 -4)),((156 43 -4,154 44 -7,157 46 -6,156 43 -4)),((158 45 -3,156 43 -4,157 46 -6,158 45 -3)),((159 48 -4,157 49 -7,159 50 -5,159 48 -4)),((159 50 -5,157 49 -7,157 151 -7,159 50 -5)),((159 150 -5,159 50 -5,157 151 -7,159 150 -5)),((153 42 -5,151 43 -7,154 44 -7,153 42 -5)),((156 43 -4,153 42 -5,154 44 -7,156 43 -4)),((159 150 -5,157 151 -7,159 152 -4,159 150 -5)),((153 42 -5,150 41 -5,151 43 -7,153 42 -5)),((160 150 -3,159 150 -5,159 152 -4,160 150 -3)),((160 150 -3,159 152 -4,160 153 -2,160 150 -3)),((159 152 -4,158 155 -3,160 153 -2,159 152 -4)),((160 153 -2,158 155 -3,159 155 0,160 153 -2)),((158 155 -3,157 157 -1,159 155 0,158 155 -3)),((160 153 -2,159 155 0,160 153 2,160 153 -2)),((160 150 0,160 153 -2,160 153 2,160 150 0)),((160 150 0,160 153 2,160 150 3,160 150 0)),((159 150 5,159 50 5,160 50 3,159 150 5)),((160 150 3,159 150 5,160 50 3,160 150 3)),((160 150 3,160 50 3,160 50 0,160 150 3)),((160 150 0,160 150 3,160 50 0,160 150 0)),((160 50 3,159 50 5,159 48 4,160 50 3)),((160 50 3,159 48 4,160 47 2,160 50 3)),((159 48 4,158 45 3,160 47 2,159 48 4)),((160 47 2,158 45 3,159 45 0,160 47 2)),((158 45 3,157 43 1,159 45 0,158 45 3)),((158 45 3,156 43 4,157 43 1,158 45 3)),((156 43 4,154 41 2,157 43 1,156 43 4)),((156 43 4,153 42 5,154 41 2,156 43 4)),((153 42 5,152 40 3,154 41 2,153 42 5)),((153 42 5,150 41 5,152 40 3,153 42 5)),((150 41 5,147 42 5,148 40 3,150 41 5)),((150 41 5,148 40 3,152 40 3,150 41 5)),((141 48 4,140 47 2,142 45 3,141 48 4)),((142 45 3,140 47 2,141 45 0,142 45 3)),((144 43 4,142 45 3,143 43 1,144 43 4)),((142 45 3,141 45 0,143 43 1,142 45 3)),((147 42 5,144 43 4,146 41 2,147 42 5)),((144 43 4,143 43 1,146 41 2,144 43 4)),((147 42 5,146 41 2,148 40 3,147 42 5)),((140 47 2,140 47 -2,141 45 0,140 47 2)),((141 45 0,140 47 -2,142 45 -3,141 45 0)),((142 45 -3,140 47 -2,141 48 -4,142 45 -3)),((143 43 -1,141 45 0,142 45 -3,143 43 -1)),((143 43 -1,142 45 -3,144 43 -4,143 43 -1)),((146 41 -2,143 43 -1,144 43 -4,146 41 -2)),((146 41 -2,144 43 -4,147 42 -5,146 41 -2)),((148 40 -3,146 41 -2,147 42 -5,148 40 -3)),((148 40 -3,147 42 -5,150 41 -5,148 40 -3)),((152 40 -3,150 41 -5,153 42 -5,152 40 -3)),((152 40 -3,148 40 -3,150 41 -5,152 40 -3)),((159 45 0,158 45 -3,160 47 -2,159 45 0)),((160 47 -2,158 45 -3,159 48 -4,160 47 -2)),((157 43 -1,156 43 -4,158 45 -3,157 43 -1)),((159 45 0,157 43 -1,158 45 -3,159 45 0)),((160 47 -2,159 48 -4,160 50 -3,160 47 -2)),((159 48 -4,159 50 -5,160 50 -3,159 48 -4)),((154 41 -2,153 42 -5,156 43 -4,154 41 -2)),((157 43 -1,154 41 -2,156 43 -4,157 43 -1)),((160 50 -3,159 50 -5,159 150 -5,160 50 -3)),((160 150 -3,160 50 -3,159 150 -5,160 150 -3)),((154 41 -2,152 40 -3,153 42 -5,154 41 -2)),((160 50 0,160 50 -3,160 150 -3,160 50 0)),((160 150 0,160 50 0,160 150 -3,160 150 0)),((160 150 -3,160 153 -2,160 150 0,160 150 -3)),((160 50 3,160 47 2,160 50 0,160 50 3)),((160 50 0,160 47 -2,160 50 -3,160 50 0)),((160 47 2,160 47 -2,160 50 0,160 47 2)),((160 47 2,159 45 0,160 47 -2,160 47 2)),((157 43 1,157 43 -1,159 45 0,157 43 1)),((157 43 1,155 41 0,157 43 -1,157 43 1)),((157 43 1,154 41 2,155 41 0,157 43 1)),((154 41 2,153 40 0,155 41 0,154 41 2)),((154 41 2,152 40 3,153 40 0,154 41 2)),((152 40 3,148 40 3,150 40 0,152 40 3)),((152 40 3,150 40 0,153 40 0,152 40 3)),((148 40 3,146 41 2,147 40 0,148 40 3)),((148 40 3,147 40 0,150 40 0,148 40 3)),((143 43 1,141 45 0,143 43 -1,143 43 1)),((143 43 1,143 43 -1,145 41 0,143 43 1)),((146 41 2,143 43 1,145 41 0,146 41 2)),((146 41 2,145 41 0,147 40 0,146 41 2)),((145 41 0,143 43 -1,146 41 -2,145 41 0)),((147 40 0,145 41 0,146 41 -2,147 40 0)),((147 40 0,146 41 -2,148 40 -3,147 40 0)),((150 40 0,148 40 -3,152 40 -3,150 40 0)),((150 40 0,147 40 0,148 40 -3,150 40 0)),((153 40 0,152 40 -3,154 41 -2,153 40 0)),((153 40 0,150 40 0,152 40 -3,153 40 0)),((155 41 0,154 41 -2,157 43 -1,155 41 0)),((155 41 0,153 40 0,154 41 -2,155 41 0)))
A square buffer around the same line using 32 segments.
SELECT
'LINESTRING(50 50,150 150,150 50)'::geometry AS input_geometry,
CG_3DBuffer('LINESTRING(50 50,150 150,150 50)'::geometry, 10, 32, 2) AS buffer;LINESTRING(50 50,150 150,150 50) | POLYHEDRALSURFACE Z (((50 36 0,50 36 -2,140 126 -2,140 126 0,50 36 0)),((140 126 -2,50 36 -2,49 36 -4,141 128 -4,140 126 -2)),((141 128 -4,49 36 -4,49 37 -6,142 130 -6,141 128 -4)),((142 130 -6,49 37 -6,48 38 -7,143 133 -7,142 130 -6)),((143 133 -7,48 38 -7,47 39 -8,144 137 -8,143 133 -7)),((144 137 -8,47 39 -8,46 40 -9,146 141 -9,144 137 -8)),((146 141 -9,46 40 -9,44 42 -10,148 145 -10,146 141 -9)),((148 145 -10,44 42 -10,43 43 -10,150 150 -10,148 145 -10)),((150 150 -10,43 43 -10,42 44 -10,152 155 -10,150 150 -10)),((152 155 -10,42 44 -10,40 46 -9,154 159 -9,152 155 -10)),((154 159 -9,40 46 -9,39 47 -8,156 163 -8,154 159 -9)),((156 163 -8,39 47 -8,38 48 -7,157 167 -7,156 163 -8)),((157 167 -7,38 48 -7,37 49 -6,158 170 -6,157 167 -7)),((158 170 -6,37 49 -6,36 49 -4,159 172 -4,158 170 -6)),((159 172 -4,36 49 -4,36 50 -2,160 174 -2,159 172 -4)),((160 174 -2,36 50 -2,36 50 -1e-15,160 174 -1e-15,160 174 -2)),((160 174 -1e-15,36 50 -1e-15,36 50 2,160 174 2,160 174 -1e-15)),((160 174 2,36 50 2,36 49 4,159 172 4,160 174 2)),((159 172 4,36 49 4,37 49 6,158 170 6,159 172 4)),((158 170 6,37 49 6,38 48 7,157 167 7,158 170 6)),((157 167 7,38 48 7,39 47 8,156 163 8,157 167 7)),((156 163 8,39 47 8,40 46 9,154 159 9,156 163 8)),((154 159 9,40 46 9,42 44 10,152 155 10,154 159 9)),((152 155 10,42 44 10,43 43 10,150 150 10,152 155 10)),((150 150 10,43 43 10,44 42 10,148 145 10,150 150 10)),((148 145 10,44 42 10,46 40 9,146 141 9,148 145 10)),((146 141 9,46 40 9,47 39 8,144 137 8,146 141 9)),((144 137 8,47 39 8,48 38 7,143 133 7,144 137 8)),((143 133 7,48 38 7,49 37 6,142 130 6,143 133 7)),((142 130 6,49 37 6,49 36 4,141 128 4,142 130 6)),((141 128 4,49 36 4,50 36 2,140 126 2,141 128 4)),((50 36 0,140 126 0,140 126 2,50 36 2,50 36 0)),((140 126 0,140 126 -2,140 40 -2,140 40 0,140 126 0)),((140 40 -2,140 126 -2,141 128 -4,141 40 -4,140 40 -2)),((141 40 -4,141 128 -4,142 130 -6,142 40 -6,141 40 -4)),((142 40 -6,142 130 -6,143 133 -7,143 40 -7,142 40 -6)),((143 40 -7,143 133 -7,144 137 -8,144 40 -8,143 40 -7)),((144 40 -8,144 137 -8,146 141 -9,146 40 -9,144 40 -8)),((146 40 -9,146 141 -9,148 145 -10,148 40 -10,146 40 -9)),((148 40 -10,148 145 -10,150 150 -10,150 40 -10,148 40 -10)),((150 40 -10,150 150 -10,152 155 -10,152 40 -10,150 40 -10)),((152 40 -10,152 155 -10,154 159 -9,154 40 -9,152 40 -10)),((154 40 -9,154 159 -9,156 163 -8,156 40 -8,154 40 -9)),((156 40 -8,156 163 -8,157 167 -7,157 40 -7,156 40 -8)),((157 40 -7,157 167 -7,158 170 -6,158 40 -6,157 40 -7)),((158 40 -6,158 170 -6,159 172 -4,159 40 -4,158 40 -6)),((159 40 -4,159 172 -4,160 174 -2,160 40 -2,159 40 -4)),((160 40 -2,160 174 -2,160 174 -1e-15,160 40 -1e-15,160 40 -2)),((160 40 -1e-15,160 174 -1e-15,160 174 2,160 40 2,160 40 -1e-15)),((160 40 2,160 174 2,159 172 4,159 40 4,160 40 2)),((159 40 4,159 172 4,158 170 6,158 40 6,159 40 4)),((158 40 6,158 170 6,157 167 7,157 40 7,158 40 6)),((157 40 7,157 167 7,156 163 8,156 40 8,157 40 7)),((156 40 8,156 163 8,154 159 9,154 40 9,156 40 8)),((154 40 9,154 159 9,152 155 10,152 40 10,154 40 9)),((152 40 10,152 155 10,150 150 10,150 40 10,152 40 10)),((150 40 10,150 150 10,148 145 10,148 40 10,150 40 10)),((148 40 10,148 145 10,146 141 9,146 40 9,148 40 10)),((146 40 9,146 141 9,144 137 8,144 40 8,146 40 9)),((144 40 8,144 137 8,143 133 7,143 40 7,144 40 8)),((143 40 7,143 133 7,142 130 6,142 40 6,143 40 7)),((142 40 6,142 130 6,141 128 4,141 40 4,142 40 6)),((141 40 4,141 128 4,140 126 2,140 40 2,141 40 4)),((140 126 0,140 40 0,140 40 2,140 126 2,140 126 0)),((50 36 -2,50 36 0,50 36 2,49 36 4,49 37 6,48 38 7,47 39 8,46 40 9,44 42 10,43 43 10,42 44 10,40 46 9,39 47 8,38 48 7,37 49 6,36 49 4,36 50 2,36 50 -1e-15,36 50 -2,36 49 -4,37 49 -6,38 48 -7,39 47 -8,40 46 -9,42 44 -10,43 43 -10,44 42 -10,46 40 -9,47 39 -8,48 38 -7,49 37 -6,49 36 -4,50 36 -2)),((140 40 0,140 40 -2,141 40 -4,142 40 -6,143 40 -7,144 40 -8,146 40 -9,148 40 -10,150 40 -10,152 40 -10,154 40 -9,156 40 -8,157 40 -7,158 40 -6,159 40 -4,160 40 -2,160 40 -1e-15,160 40 2,159 40 4,158 40 6,157 40 7,156 40 8,154 40 9,152 40 10,150 40 10,148 40 10,146 40 9,144 40 8,143 40 7,142 40 6,141 40 4,140 40 2,140 40 0)))
CG_Rotate — Roterar en geometri med en given vinkel runt origo (0,0).
geometry CG_Rotate(geometry geom, float8 angle);
Roterar indatageometrin geom med vinkelradianer runt ursprungspunkten (0,0). Rotationen utförs i 2D-rymden; Z-koordinaterna ändras inte. Positiva vinklar roterar geometrin moturs.
Tillgänglighet: 3.6.0 - kräver SFCGAL >= 2.0.0
Denna metod behöver SFCGAL-backend.
SELECT CG_Rotate('LINESTRING(1 0,0 1)', pi()/2);LINESTRING(6.123233995736766e-17 1,-1 6.123233995736766e-17)
CG_2DRotate — Roterar en geometri med en given vinkel runt en angiven punkt i 2D.
geometry CG_2DRotate(geometry geom, float8 angle, float8 cx, float8 cy);
Roterar indatageometrin geom med angle-radianer runt punkten (cx, cy). Rotationen utförs i 2D-rymd; Z-koordinater utelämnas. Positiva vinklar roterar geometrin moturs.
Tillgänglighet: 3.6.0 - kräver SFCGAL >= 2.0.0
Denna metod behöver SFCGAL-backend.
SELECT CG_2DRotate('POINT(1 0)', pi()/2, 1, 1);POINT(2 1)
CG_3DRotate — Roterar en geometri i 3D-rymden runt en axelvektor.
geometry CG_3DRotate(geometry geom, float8 angle, float8 ax, float8 ay, float8 az);
Roterar indatageometrin geom med vinkelradianer runt en axel som definieras av vektorn(ax, ay, az) som passerar genom origo (0,0,0).
Tillgänglighet: 3.6.0 - kräver SFCGAL >= 2.0.0
Denna metod behöver SFCGAL-backend.
Denna funktion stöder 3d och kommer inte att tappa z-index.
SELECT CG_3DRotate('POINT(1 0 0)', pi()/2, 0, 0, 1);POINT Z (6.123233995736766e-17 1 0)
CG_RotateX — Roterar en geometri runt X-axeln med en given vinkel.
geometry CG_RotateX(geometry geom, float8 angle);
Roterar indatageometrin geom med vinkelradianer runt X-axeln.
Tillgänglighet: 3.6.0 - kräver SFCGAL >= 2.0.0
Denna metod behöver SFCGAL-backend.
Denna funktion stöder 3d och kommer inte att tappa z-index.
SELECT CG_RotateX('POINT(0 1 0)', pi()/2);POINT Z (0 6.123233995736766e-17 1)
CG_RotateY — Roterar en geometri runt Y-axeln med en given vinkel.
geometry CG_RotateY(geometry geom, float8 angle);
Roterar indatageometrin geom med vinkelradianer runt Y-axeln passerar.
Tillgänglighet: 3.6.0 - kräver SFCGAL >= 2.0.0
Denna metod behöver SFCGAL-backend.
Denna funktion stöder 3d och kommer inte att tappa z-index.
SELECT CG_RotateY('POINT(1 0 0)', pi()/2);POINT Z (6.123233995736766e-17 0 -1)
CG_RotateZ — Roterar en geometri runt Z-axeln med en given vinkel.
geometry CG_RotateZ(geometry geom, float8 angle);
Roterar indatageometrin geom med vinkelradianer runt Z-axeln.
Tillgänglighet: 3.6.0 - kräver SFCGAL >= 2.0.0
Denna metod behöver SFCGAL-backend.
Denna funktion stöder 3d och kommer inte att tappa z-index.
SELECT CG_RotateZ('POINT(1 0 0)', pi()/2);POINT Z (6.123233995736766e-17 1 0)
CG_Scale — Skalar en geometri enhetligt i alla dimensioner med en given faktor.
geometry CG_Scale(geometry geom, float8 factor);
Skalar inmatningsgeometrin geom med en enhetlig skalfaktor i alla dimensioner (X, Y och Z). Skalningen utförs i förhållande till ursprungspunkten (0,0,0).
Tillgänglighet: 3.6.0 - kräver SFCGAL >= 2.0.0
Denna metod behöver SFCGAL-backend.
SELECT CG_Scale('LINESTRING(1 1,2 2)', 2);LINESTRING(2 2,4 4)
CG_3DScale — Skalar en geometri med separata faktorer längs X-, Y- och Z-axlarna.
geometry CG_3DScale(geometry geom, float8 factorX, float8 factorY, float8 factorZ);
Skalar inmatningsgeometrin geom med olika faktorer längs X-, Y- och Z-axlarna. Skalningen utförs i förhållande till ursprungspunkten (0,0,0).
Tillgänglighet: 3.6.0 - kräver SFCGAL >= 2.0.0
Denna metod behöver SFCGAL-backend.
Denna funktion stöder 3d och kommer inte att tappa z-index.
SELECT CG_3DScale('POINT(1 1 1)', 2, 3, 4);POINT Z (2 3 4)
CG_3DScaleAroundCenter — Skalar en geometri i 3D-rymden runt en angiven mittpunkt.
geometry CG_3DScaleAroundCenter(geometry geom, float8 factorX, float8 factorY, float8 factorZ, float8 centerX, float8 centerY, float8 centerZ);
Skalar indatageometrin geom med olika faktorer längs X-, Y- och Z-axlarna i förhållande till en angiven mittpunkt (centerX, centerY, centerZ).
Tillgänglighet: 3.6.0 - kräver SFCGAL >= 2.0.0
Denna metod behöver SFCGAL-backend.
Denna funktion stöder 3d och kommer inte att tappa z-index.
SELECT CG_3DScaleAroundCenter('POINT(2 2 2)', 0.5, 0.5, 0.5, 1, 1, 1);POINT Z (1.5 1.5 1.5)
CG_Translate — Translaterar (flyttar) en geometri med hjälp av givna offsets i 2D-rymden.
geometry CG_Translate(geometry geom, float8 deltaX, float8 deltaY);
Translaterar indatageometrin geom genom att lägga till deltaX till X-koordinaterna och deltaY till Y-koordinaterna. Z-koordinater utelämnas.
Tillgänglighet: 3.6.0 - kräver SFCGAL >= 2.0.0
Denna metod behöver SFCGAL-backend.
SELECT CG_Translate('LINESTRING(1 1,2 2)', 1, -1);LINESTRING(2 0,3 1)
CG_3DTranslate — Translaterar (flyttar) en geometri med hjälp av givna offsets i 3D-rymden.
geometry CG_3DTranslate(geometry geom, float8 deltaX, float8 deltaY, float8 deltaZ);
Translaterar indatageometrin geom genom att lägga till deltaX till X-koordinaterna, deltaY till Y-koordinaterna och deltaZ till Z-koordinaterna.
Tillgänglighet: 3.6.0 - kräver SFCGAL >= 2.0.0
Denna metod behöver SFCGAL-backend.
Denna funktion stöder 3d och kommer inte att tappa z-index.
SELECT CG_3DTranslate('POINT(1 1 1)', 1, -1, 2);POINT Z (2 0 3)
CG_Simplify — Minskar komplexiteten i en geometri samtidigt som viktiga egenskaper och Z/M-värden bevaras.
geometry CG_Simplify(geometry geom, double precision threshold, boolean preserveTopology = false);
Förenklar en geometri med hjälp av SFCGAL:s förenklingsalgoritm, som minskar antalet punkter eller hörn samtidigt som geometrins väsentliga egenskaper bevaras. Denna funktion bevarar Z- och M-värden under förenklingen.
Algoritmen är baserad på begränsad triangulering och använder CGAL Polyline Simplification 2-biblioteket med ytterligare hantering för att bevara Z- och M-koordinater. När topologin bevaras och geometrierna korsar varandra interpoleras Z- och M-värdena vid skärningspunkterna.
Denna funktion fungerar bra med 3D-terrängliknande geometrier (2,5D) men är inte utformad för vertikala ytor som väggar.
Tillgänglighet: 3.6.0 - kräver SFCGAL >= 2.1.0
Denna metod behöver SFCGAL-backend.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Denna funktion stöder M-koordinater.
geomGeometri för inmatning
tröskelvärdeTröskelvärde för maximalt avstånd (i geometrisk enhet) för förenkling. Ju högre detta värde är, desto mer förenklad blir den resulterande geometrin.
bevaraTopologiOm funktionen är inställd på true säkerställer den att geometrins topologi bevaras. När geometrier korsas i detta läge interpoleras Z- och M-värdena vid skärningspunkterna. Standardvärdet är false.
Returnerar en förenklad geometri med bevarade Z- och M-värden.
This example simplifies a polygon with a threshold of 0.5.
SELECT CG_Simplify(
'POLYGON((0 0,0 1,0.1 1,0.2 1,0.3 1,0.4 1,0.5 1,1 1,1 0,0 0))',
0.5
);POLYGON((0 0,0 1,1 1,1 0,0 0))
Preserving topology can keep additional support points in a mixed ZM collection.
SELECT CG_Simplify(
'GEOMETRYCOLLECTION ZM(
LINESTRING ZM(-1 -1 3 4,0 0 10 100,1 1 20 200,0 2 15 150,0 5 30 300,2 19 25 250,-4 20 15 150),
POLYGON ZM((0 0 10 100,1 1 20 200,0 2 15 150,0 5 30 300,2 19 25 250,-4 20 15 150,0 0 10 100))
)',
2,
false
);GEOMETRYCOLLECTION ZM (LINESTRING ZM (-1 -1 3 4,2 19 25 250,-4 20 15 150),POLYGON ZM ((0 0 10 100,2 19 25 250,-4 20 15 150,0 0 10 100)))
The topology-preserving variant keeps the shared anchor point at the collection intersection.
SELECT CG_Simplify(
'GEOMETRYCOLLECTION ZM(
LINESTRING ZM(-1 -1 3 4,0 0 10 100,1 1 20 200,0 2 15 150,0 5 30 300,2 19 25 250,-4 20 15 150),
POLYGON ZM((0 0 10 100,1 1 20 200,0 2 15 150,0 5 30 300,2 19 25 250,-4 20 15 150,0 0 10 100))
)',
2,
true
);GEOMETRYCOLLECTION ZM (LINESTRING ZM (-1 -1 3 4,0 0 10 100,2 19 25 250,-4 20 15 150),POLYGON ZM ((0 0 10 100,2 19 25 250,-4 20 15 150,0 0 10 100)))
Compare simplification with and without topology preservation, using a threshold of 50.
WITH data AS (
SELECT ST_GeomFromText('GEOMETRYCOLLECTION(
POLYGON((88.46 158.85,90.77 171.54,147.31 173.85,146.15 145,173.85 119.62,146.15 103.46,112.69 118.46,91.92 93.08,65.38 101.15,34.23 121.92,41.15 142.69,49.23 143.85,88.46 158.85)),
POLYGON((112.69 118.46,146.15 103.46,190 60.77,185.38 43.46,126.54 26.15,83.85 28.46,67.69 64.23,43.46 58.46,10 83.85,34.23 121.92,65.38 101.15,91.92 93.08,112.69 118.46)))
') AS geom
)
SELECT geom AS input_geometry,
CG_Simplify(geom, 50, true) AS topology_preserved,
CG_Simplify(geom, 50, false) AS topology_not_preserved
FROM data;GEOMETRYCOLLECTION(POLYGON((88.46 158.85,90.77 171.54,147.31 173.85,146.15 145,173.85 119.62,146.15 103.46,112.69 118.46,91.92 93.08,65.38 101.15,34.23 121.92,41.15 142.69,49.23 143.85,88.46 158.85)), POLYGON((112.69 118.46,146.15 103.46,190 60.77,185.38 43.46,126.54 26.15,83.85 28.46,67.69 64.23,43.46 58.46,10 83.85,34.23 121.92,65.38 101.15,91.92 93.08,112.69 118.46))) | GEOMETRYCOLLECTION(POLYGON((88.46 158.85,147.31 173.85,146.15 103.46,112.69 118.46,34.23 121.92,88.46 158.85)), POLYGON((112.69 118.46,146.15 103.46,185.38 43.46,10 83.85,34.23 121.92,112.69 118.46))) | GEOMETRYCOLLECTION(POLYGON((88.46 158.85,173.85 119.62,34.23 121.92,88.46 158.85)), POLYGON((112.69 118.46,190 60.77,10 83.85,112.69 118.46)))
CG_3DAlphaWrapping — Beräknar en 3D Alpha-wrapping som strikt omsluter en geometri.
geometry CG_3DAlphaWrapping(geometry geom, integer relative_alpha, integer relative_offset);
Beräknar 3D-alfaomslaget för punkterna i en geometri. En alfaförpackning är ett vattentätt och orienterbart ytnät som strikt omsluter indata. Det kan ses som en utvidgning eller förfining av en alfa-form.
The relative_alpha parameter controls which features will appear in the output. It can have values from 0 to infinity. Higher relative_alpha values produce coarser wraps; lower values retain more detail.
The relative_offset parameter controls the tightness of the result. It can have values from 0 to infinity. If this parameter is set to 0, its value is automatically determined based on the relative_alpha parameter.
Tillgänglighet: 3.6.0 - kräver SFCGAL >= 2.1.0
Denna metod behöver SFCGAL-backend.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Wrap a tetrahedral surface and show the native 3D input beside the actual enclosing mesh.
WITH data AS (
SELECT 'POLYHEDRALSURFACE Z (
((0 0 0,4 0 0,0 4 0,0 0 0)),
((0 0 0,0 0 4,4 0 0,0 0 0)),
((0 0 0,0 4 0,0 0 4,0 0 0)),
((4 0 0,0 0 4,0 4 0,4 0 0))
)'::geometry AS input_geometry
)
SELECT input_geometry AS input_geometry,
CG_3DAlphaWrapping(input_geometry, 1)
AS wrapped_geometry
FROM data;POLYHEDRALSURFACE Z (((0 0 0,4 0 0,0 4 0,0 0 0)),((0 0 0,0 0 4,4 0 0,0 0 0)),((0 0 0,0 4 0,0 0 4,0 0 0)),((4 0 0,0 0 4,0 4 0,4 0 0))) | POLYHEDRALSURFACE Z (((-0.193 0.127 4,-0.035 -0.228 4.004,0.087 0.087 4.195,-0.193 0.127 4)),((0.083 0.082 3.801,0.087 0.087 4.195,-0.035 -0.228 4.004,0.083 0.082 3.801)),((0.087 0.087 4.195,0.083 0.082 3.801,-0.193 0.127 4,0.087 0.087 4.195)),((0.048 3.84 0.16,3.867 0.133 0.133,0.091 3.926 -0.199,0.048 3.84 0.16)),((3.92 0.08 -0.201,0.037 -0.007 -0.228,0.091 3.926 -0.199,3.92 0.08 -0.201)),((3.867 0.133 0.133,3.92 0.08 -0.201,0.091 3.926 -0.199,3.867 0.133 0.133)),((3.867 0.133 0.133,3.877 -0.195 0.012,4.228 -0.006 0.037,3.867 0.133 0.133)),((3.867 0.133 0.133,4.228 -0.006 0.037,3.92 0.08 -0.201,3.867 0.133 0.133)),((3.877 -0.195 0.012,3.92 0.08 -0.201,4.228 -0.006 0.037,3.877 -0.195 0.012)),((0.012 -0.196 0.121,-0.035 -0.228 4.004,-0.202 0.079 0.078,0.012 -0.196 0.121)),((-0.202 0.079 0.078,0.037 -0.007 -0.228,0.012 -0.196 0.121,-0.202 0.079 0.078)),((3.867 0.133 0.133,0.083 0.082 3.801,3.877 -0.195 0.012,3.867 0.133 0.133)),((0.091 3.926 -0.199,0.101 4.199 0.06,0.048 3.84 0.16,0.091 3.926 -0.199)),((0.101 4.199 0.06,-0.228 4.028 -0.021,0.048 3.84 0.16,0.101 4.199 0.06)),((0.091 3.926 -0.199,-0.228 4.028 -0.021,0.101 4.199 0.06,0.091 3.926 -0.199)),((3.867 0.133 0.133,0.048 3.84 0.16,0.083 0.082 3.801,3.867 0.133 0.133)),((3.877 -0.195 0.012,0.037 -0.007 -0.228,3.92 0.08 -0.201,3.877 -0.195 0.012)),((0.012 -0.196 0.121,0.037 -0.007 -0.228,3.877 -0.195 0.012,0.012 -0.196 0.121)),((0.083 0.082 3.801,0.048 3.84 0.16,-0.193 0.127 4,0.083 0.082 3.801)),((-0.228 4.028 -0.021,-0.193 0.127 4,0.048 3.84 0.16,-0.228 4.028 -0.021)),((-0.228 4.028 -0.021,-0.202 0.079 0.078,-0.193 0.127 4,-0.228 4.028 -0.021)),((-0.202 0.079 0.078,-0.035 -0.228 4.004,-0.193 0.127 4,-0.202 0.079 0.078)),((3.877 -0.195 0.012,0.083 0.082 3.801,-0.035 -0.228 4.004,3.877 -0.195 0.012)),((0.012 -0.196 0.121,3.877 -0.195 0.012,-0.035 -0.228 4.004,0.012 -0.196 0.121)),((0.091 3.926 -0.199,0.037 -0.007 -0.228,-0.228 4.028 -0.021,0.091 3.926 -0.199)),((-0.228 4.028 -0.021,0.037 -0.007 -0.228,-0.202 0.079 0.078,-0.228 4.028 -0.021)))
CG_NurbsCurveInterpolate — Creates an interpolating NURBS curve passing through all given data points
geometry CG_NurbsCurveInterpolate(geometry data_points, integer degree);
Creates a NURBS curve that interpolates through all provided data points. The resulting curve passes exactly through each point in the input geometry.
Parameters:
data_points - A LINESTRING geometry containing the points to interpolate through.
degree - Polynomial degree of the NURBS curve (typically 2 or 3).
Availability: 3.7.0 - requires SFCGAL >= 2.3.0.
Denna metod behöver SFCGAL-backend.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Interpolate a degree-3 NURBS curve through four 2D points.
WITH data AS (
SELECT 'LINESTRING(0 0,2 5,5 3,8 1)'::geometry AS input_points
)
SELECT input_points AS input_points,
CG_NurbsCurveInterpolate(input_points, 3) AS interpolated_curve
FROM data;LINESTRING(0 0,2 5,5 3,8 1) | NURBSCURVE(DEGREE 3, CONTROLPOINTS(NURBSPOINT(WEIGHTEDPOINT(0 0),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT(-0.43 10.29),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT(4.95 1.9),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT(8 1),WEIGHT 1)),KNOTS (KNOT(0,4), KNOT(1,4)))
Interpolate a 3D degree-3 NURBS curve through the documented control points.
WITH data AS (
SELECT 'LINESTRING Z (0 0 0,2 5 2,5 3 1,8 1 0)'::geometry AS input_points
)
SELECT input_points AS input_points,
CG_NurbsCurveInterpolate(input_points, 3) AS interpolated_curve
FROM data;LINESTRING Z (0 0 0,2 5 2,5 3 1,8 1 0) | NURBSCURVE Z (DEGREE 3,CONTROLPOINTS Z (NURBSPOINT(WEIGHTEDPOINT Z (0 0 0),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT Z (-0.43 10.29 4.36),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT Z (4.95 1.9 0.54),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT Z (8 1 0),WEIGHT 1)),KNOTS (KNOT(0,4), KNOT(1,4)))
CG_NurbsCurveApproximate — Creates an approximating NURBS curve fitting data points within a tolerance
geometry CG_NurbsCurveApproximate(geometry data_points, integer degree, float8 tolerance, integer max_control_points=100);
Creates a NURBS curve that approximates the given data points within the specified tolerance. Unlike interpolation, the curve does not necessarily pass through all points but provides a smooth fit with fewer control points.
Parameters:
data_points - A LINESTRING geometry containing the points to approximate.
degree - Polynomial degree of the NURBS curve.
tolerance - Maximum allowed distance between the curve and data points.
max_control_points - Optional maximum number of control points (default: 100). Limits curve complexity.
Availability: 3.7.0 - requires SFCGAL >= 2.3.0.
Denna metod behöver SFCGAL-backend.
Denna funktion stöder 3d och kommer inte att tappa z-index.
Approximate noisy 2D data with a degree-2 curve and a tolerance of 0.5.
WITH data AS (
SELECT 'LINESTRING(0 0,1 2.1,2 1.9,3 3.2,4 2.8,5 1)'::geometry AS input_points
)
SELECT input_points AS input_points,
CG_NurbsCurveApproximate(input_points, 2, 0.5) AS approximated_curve
FROM data;LINESTRING(0 0,1 2.1,2 1.9,3 3.2,4 2.8,5 1) | NURBSCURVE(DEGREE 2, CONTROLPOINTS(NURBSPOINT(WEIGHTEDPOINT(0 0),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT(-0.05 2.64),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT(2.24 1.65),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT(2.79 3.48),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT(4.84 2.43),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT(5 1),WEIGHT 1)),KNOTS (KNOT(0,3), KNOT(0.35,1), KNOT(0.51,1), KNOT(0.68,1), KNOT(1,3)))
Approximate a 3D point set while preserving the Z dimension in the fitted curve.
WITH data AS (
SELECT 'LINESTRING Z (0 0 0,1 2 1,2 3 2,3 2 1,4 1 0,5 0 0)'::geometry AS input_points
)
SELECT input_points AS input_points,
CG_NurbsCurveApproximate(input_points, 3, 0.1) AS approximated_curve
FROM data;LINESTRING Z (0 0 0,1 2 1,2 3 2,3 2 1,4 1 0,5 0 0) | NURBSCURVE Z (DEGREE 3,CONTROLPOINTS Z (NURBSPOINT(WEIGHTEDPOINT Z (0 0 0),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT Z (0.18 -0.15 -1.29),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT Z (1.49 4.36 3.35),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT Z (3.33 1.33 0.38),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT Z (4.34 0.83 -0.44),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT Z (5 0 0),WEIGHT 1)),KNOTS (KNOT(0,4), KNOT(0.46,1), KNOT(0.64,1), KNOT(1,4)))
CG_NurbsCurveDerivative — Computes the derivative (tangent, curvature) of a NURBS curve at a given parameter
geometry CG_NurbsCurveDerivative(geometry nurbscurve, float8 parameter, integer derivative_order);
Computes the derivative of a NURBS curve at a specific parameter value. The derivative represents the rate of change at that point:
Order 1: Tangent vector (direction and speed)
Order 2: Curvature vector (how the tangent changes)
Order 3: Third-order derivative (supported maximum)
Parameters:
nurbscurve - A NURBS curve geometry.
parameter - Parameter value for evaluation (typically 0.0 to 1.0).
derivative_order - Order of derivative to compute (1, 2, or 3).
Returns a POINT geometry representing the derivative vector at the specified parameter.
Availability: 3.7.0 - requires SFCGAL >= 2.3.0.
Denna metod behöver SFCGAL-backend.
Denna funktion stöder 3d och kommer inte att tappa z-index.
The first derivative gives the tangent vector at the evaluation parameter.
WITH data AS (
SELECT 'NURBSCURVE (2, (0.00 0.00, 5.00 10.00, 10.00 0.00))'::geometry AS input_curve
)
SELECT input_curve AS input_curve,
CG_NurbsCurveDerivative(input_curve, 0.5, 1) AS tangent
FROM data;NURBSCURVE(DEGREE 2, CONTROLPOINTS(NURBSPOINT(WEIGHTEDPOINT(0 0),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT(5 10),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT(10 0),WEIGHT 1)),KNOTS (KNOT(0,3), KNOT(1,3))) | POINT Z (10 0 0)
The second derivative exposes curvature change for a higher-degree curve.
WITH data AS (
SELECT 'NURBSCURVE (3, (0.00 0.00, 2.00 8.00, 5.00 5.00, 8.00 2.00, 10.00 0.00))'::geometry AS input_curve
)
SELECT input_curve AS input_curve,
CG_NurbsCurveDerivative(input_curve, 0.5, 2) AS curvature
FROM data;NURBSCURVE(DEGREE 3, CONTROLPOINTS(NURBSPOINT(WEIGHTEDPOINT(0 0),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT(2 8),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT(5 5),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT(8 2),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT(10 0),WEIGHT 1)),KNOTS (KNOT(0,4), KNOT(0.5,1), KNOT(1,4))) | POINT Z (9 -9 0)
The same derivative call also works for 3D NURBS curves.
WITH data AS (
SELECT 'NURBSCURVE Z (2, (0.00 0.00 0.00, 5.00 10.00 5.00, 10.00 0.00 0.00))'::geometry AS input_curve
)
SELECT input_curve AS input_curve,
CG_NurbsCurveDerivative(input_curve, 0.5, 1) AS tangent
FROM data;NURBSCURVE Z (DEGREE 2,CONTROLPOINTS Z (NURBSPOINT(WEIGHTEDPOINT Z (0 0 0),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT Z (5 10 5),WEIGHT 1), NURBSPOINT(WEIGHTEDPOINT Z (10 0 0),WEIGHT 1)),KNOTS (KNOT(0,3), KNOT(1,3))) | POINT Z (10 0 0)
CG_3DIntersection.CG_3DDifference.CG_3DUnion.CG_Tesselate.CG_3DArea.CG_Extrude.CG_ForceLHR.CG_Orientation.CG_MinkowskiSum.CG_StraightSkeleton.CG_ApproximateMedialAxis.CG_IsPlanar.CG_Volume.CG_MakeSolid.CG_IsSolid.CG_ConstrainedDelaunayTriangles.CG_3DConvexHull.CG_AlphaShape.CG_OptimalAlphaShape.
These ST_ names remain available for compatibility and emit deprecation notices.
Their entries contain only the legacy signature and migration link. Use the corresponding
CG_ pages for behavior, examples, and geometry support details.
ST_3DIntersection — Deprecated alias for CG_3DIntersection.
geometry ST_3DIntersection(geometry geom1, geometry geom2);
![]() | |
|
Availability: 2.1.0
Denna metod behöver SFCGAL-backend.
ST_3DDifference — Deprecated alias for CG_3DDifference.
geometry ST_3DDifference(geometry geom1, geometry geom2);
![]() | |
|
Availability: 2.2.0
Denna metod behöver SFCGAL-backend.
ST_3DUnion — Deprecated alias for CG_3DUnion.
geometry ST_3DUnion(geometry geom1, geometry geom2);
geometry ST_3DUnion(geometry set g1field);
![]() | |
|
Availability: 2.2.0
Denna metod behöver SFCGAL-backend.
ST_Tesselate — Deprecated alias for CG_Tesselate.
geometry ST_Tesselate(geometry geom);
![]() | |
|
Availability: 2.1.0
Denna metod behöver SFCGAL-backend.
ST_3DArea — Deprecated alias for CG_3DArea.
floatST_3DArea(geometry geom1);
![]() | |
|
Availability: 2.1.0
Denna metod behöver SFCGAL-backend.
ST_Extrude — Deprecated alias for CG_Extrude.
geometry ST_Extrude(geometry geom, float x, float y, float z);
![]() | |
|
Availability: 2.1.0
Denna metod behöver SFCGAL-backend.
ST_ForceLHR — Deprecated alias for CG_ForceLHR.
geometry ST_ForceLHR(geometry geom);
![]() | |
|
Availability: 2.1.0
Denna metod behöver SFCGAL-backend.
ST_Orientation — Deprecated alias for CG_Orientation.
integer ST_Orientation(geometry geom);
![]() | |
|
Availability: 2.1.0
Denna metod behöver SFCGAL-backend.
ST_MinkowskiSum — Deprecated alias for CG_MinkowskiSum.
geometry ST_MinkowskiSum(geometry geom1, geometry geom2);
![]() | |
|
Availability: 2.1.0
Denna metod behöver SFCGAL-backend.
ST_StraightSkeleton — Deprecated alias for CG_StraightSkeleton.
geometry ST_StraightSkeleton(geometry geom);
![]() | |
|
Availability: 2.1.0
Denna metod behöver SFCGAL-backend.
ST_ApproximateMedialAxis — Deprecated alias for CG_ApproximateMedialAxis.
geometry ST_ApproximateMedialAxis(geometry geom);
![]() | |
|
Availability: 2.2.0
Denna metod behöver SFCGAL-backend.
ST_IsPlanar — Deprecated alias for CG_IsPlanar.
boolean ST_IsPlanar(geometry geom);
![]() | |
|
Availability: 2.2.0: This was documented in 2.1.0 but got accidentally left out in 2.1 release.
Denna metod behöver SFCGAL-backend.
ST_Volume — Deprecated alias for CG_Volume.
float ST_Volume(geometry geom1);
![]() | |
|
Availability: 2.2.0
Denna metod behöver SFCGAL-backend.
ST_MakeSolid — Deprecated alias for CG_MakeSolid.
geometry ST_MakeSolid(geometry geom1);
![]() | |
|
Availability: 2.2.0
Denna metod behöver SFCGAL-backend.
ST_IsSolid — Deprecated alias for CG_IsSolid.
boolean ST_IsSolid(geometry geom1);
![]() | |
|
Availability: 2.2.0
Denna metod behöver SFCGAL-backend.
ST_ConstrainedDelaunayTriangles — Deprecated alias for CG_ConstrainedDelaunayTriangles.
geometry ST_ConstrainedDelaunayTriangles(geometry g1);
![]() | |
|
Availability: 3.0.0
Denna metod behöver SFCGAL-backend.
ST_3DConvexHull — Deprecated alias for CG_3DConvexHull.
geometry ST_3DConvexHull(geometry geom1);
![]() | |
|
Availability: 3.3.0
Denna metod behöver SFCGAL-backend.
ST_AlphaShape — Deprecated alias for CG_AlphaShape.
geometry ST_AlphaShape(geometry geom,
float
alpha
,
boolean
allow_holes = false
);
![]() | |
|
Denna metod behöver SFCGAL-backend.
ST_OptimalAlphaShape — Deprecated alias for CG_OptimalAlphaShape.
geometry ST_OptimalAlphaShape(geometry geom,
boolean
allow_holes = false
,
integer
nb_components = 1
);
![]() | |
|
Availability: 3.3.0 - requires SFCGAL >= 1.4.1.
Denna metod behöver SFCGAL-backend.
PostGIS Topology-typer och -funktioner används för att hantera topologiska objekt som ytor, kanter och noder.
Sandro Santillis presentation på konferensen PostGIS Day Paris 2011 ger en bra sammanfattning av PostGIS Topology och vart det är på väg Topology with PostGIS 2.0 slide deck..
Vincent Picavet ger en bra sammanfattning och översikt över vad Topology är, hur det används och olika FOSS4G-verktyg som stöder det i PostGIS Topology PGConf EU 2012.
An example of a topologically based GIS database is the US Census Topologically Integrated Geographic Encoding and Referencing System (TIGER) database. If you want to experiment with PostGIS topology and need some data.
The PostGIS topology module has existed for a long time but was not always part of the official documentation. Extensive cleanup removed deprecated functions, fixed known usability issues, documented the features and functions, added new functionality, and improved SQL-MM compliance.
This chapter is the maintained reference for the topology module, including its primitive tables, TopoGeometry type, topology management functions, editing functions, validation functions, and conversion helpers.
Alla funktioner och tabeller som är kopplade till denna modul är installerade i ett schema som kallas topologi.
Funktioner som är definierade i SQL/MM-standarden har prefixet ST_ och funktioner som är specifika för PostGIS har inget prefix.
Topology support is built by default and can be disabled by specifying the --without-topology configure option at build time as described in Kapitel 2, Installation av PostGIS
The core primitives of any topology are stored in the edge_data, node, and face tables that live in the schema created by CreateTopology. Each row of edge_data represents an oriented edge: it records a directed curve from start_node to end_node together with the identifier of the face encountered on the left of that direction (left_face) and the face encountered on the right (right_face). The same geometric segment may therefore appear twice—once for each orientation—when it belongs to two faces.
The next_left_edge and next_right_edge columns complete this orientation information by encoding how to keep walking around a face. They store signed integers whose absolute value is the identifier of the next oriented edge and whose sign determines whether the stored orientation has to be followed as-is or reversed when traversing. Formally, the following rules hold for every edge e:
abs(next_left_edge) is the identifier of the edge reached by continuing around the face that lies to the left of e. If the value is positive the walk continues from the end node of e along the stored orientation of the referenced edge; if it is negative the referenced edge must be followed backwards so that the shared face remains on the walker’s left.
abs(next_right_edge) analogously follows the boundary of the face located on the right of e. A positive value means that the next edge is taken with its recorded orientation starting from the end node of e, whereas a negative value instructs to traverse the referenced edge in reverse, starting from its end node, so that the right-hand face is preserved.
A zero value indicates that the edge is dangling on the corresponding side (for example an isolated edge whose incident face is the universal face 0). The abs_next_left_edge and abs_next_right_edge columns exposed by the edge view are convenience projections of these absolute values.
This representation is a variant of a doubly connected edge list and is exploited by many topology routines. Functions such as GetRingEdges and ValidateTopology rely on it to reconstruct face boundaries and to diagnose inconsistencies—hence the “invalid next_left_edge” and “invalid next_right_edge” diagnostics reported during validation. Constructors like AddEdge initialise the next_* attributes with trivial self references, while editing routines including ST_AddEdgeModFace and ST_RemEdgeModFace update the links as edges are inserted or removed. Other bulk operations (for example Polygonize) may intentionally leave the fields unset, which is why the documentation flags their behaviour explicitly.
Detta avsnitt listar PostgreSQL-datatyper installerade av PostGIS Topology. Observera att vi beskriver casting-beteendet för dessa, vilket är mycket viktigt, särskilt när du utformar dina egna funktioner.
ValidateTopology.getfaceedges_returntype — En sammansatt typ som består av ett sekvensnummer och ett kantnummer.
En sammansatt typ som består av ett sekvensnummer och ett kantnummer. Detta är returtypen för funktionerna ST_GetFaceEdges och GetNodeEdges.
sequence är ett heltal: Hänvisar till en topologi som definieras i tabellen topology.topology som definierar topologins schema och srid.
edge är ett heltal: Identifieraren för en kant.
TopoGeometry — En sammansatt typ som representerar en topologiskt definierad geometri.
En sammansatt typ som hänvisar till en topologisk geometri i ett specifikt topologiskt lager, med en specifik typ och ett specifikt id. Elementen i en TopoGeometry är egenskaperna: topology_id, layer_id, id integer, type integer.
topology_id är ett heltal: Hänvisar till en topologi som definieras i tabellen topology.topology som definierar topologins schema och srid.
layer_id är ett heltal: Det layer_id i layer-tabellen som TopoGeometry hör till. Kombinationen av topology_id och layer_id ger en unik referens i tabellen topology.layers.
id är ett heltal: Id är det autogenererade sekvensnumret som unikt definierar topogeometrin i respektive topologilager.
type heltal mellan 1 - 4 som definierar geometritypen: 1:[multi]punkt, 2:[multi]linje, 3:[multi]poly, 4:samling
I detta avsnitt listas de automatiska såväl som explicita kast som är tillåtna för denna datatyp
| Kasta till | Beteende |
|---|---|
| geometri | automatisk |
validatetopology_returntype — En sammansatt typ som består av ett felmeddelande samt id1 och id2 för att ange var felet finns. Detta är returtypen för ValidateTopology.
En sammansatt typ som består av ett felmeddelande och två heltal. Funktionen ValidateTopology returnerar en uppsättning av dessa för att beteckna valideringsfel och id1 och id2 för att beteckna id för de topologiobjekt som är inblandade i felet.
| Field | Type | Description |
|---|---|---|
error | varchar |
Denotes the type of error. Current error descriptors are: coincident nodes, edge crosses node, edge not simple, edge end node geometry mismatch, edge start node geometry mismatch, face overlaps face, face within face. |
id1 | integer | Denotes the identifier of the edge, face, or node in error. |
id2 | integer | For errors that involve two objects, denotes the secondary edge or node. |
Detta avsnitt listar PostgreSQL-domänerna installerade av PostGIS Topology. Domäner kan användas som objekttyper som returobjekt för funktioner eller tabellkolumner. Skillnaden mellan en domän och en typ är att en domän är en befintlig typ med en kontrollbegränsning bunden till den.
TopoElement — En matris med 2 heltal som vanligtvis används för att identifiera en TopoGeometry-komponent.
En matris med 2 heltal som används för att representera en komponent i en enkel eller hierarkisk TopoGeometry.
När det gäller en enkel TopoGeometry representerar det första elementet i matrisen identifieraren för en topologisk primitiv och det andra elementet representerar dess typ (1:nod, 2:kant, 3:yta). När det gäller en hierarkisk TopoGeometry representerar det första elementet i matrisen identifieraren för en underordnad TopoGeometry och det andra elementet representerar dess lageridentifierare.
![]() | |
För varje given hierarkisk TopoGeometry kommer alla underordnade TopoGeometry-element att komma från samma underordnade lager, enligt vad som anges i topology.layer-posten för lagret i den TopoGeometry som definieras. |
SELECT te[1] AS id, te[2] AS type FROM ( SELECT ARRAY[1, 2]::topology.topoelement AS te ) f;
id | type
----+------
1 | 2
SELECT ARRAY[1, 2]::topology.topoelement;
te
-------
{1,2}
This example shows what happens when casting a three-element array to topology.topoelement. The domain requires a two-element array, so the dimension check fails.
SELECT ARRAY[1, 2, 3]::topology.topoelement;
ERROR: value for domain topology.topoelement violates check constraint "dimensions"
TopoElementArray — En array av TopoElement-objekt.
En array med 1 eller flera TopoElement-objekt, som vanligtvis används för att skicka runt komponenter i TopoGeometry-objekt.
SELECT '{{1,2},{4,3}}'::topology.topoelementarray AS tea;{{1,2},{4,3}}This is the more verbose equivalent.
SELECT ARRAY[ARRAY[1, 2], ARRAY[4, 3]]::topology.topoelementarray AS tea;
{{1,2},{4,3}}This example uses the array aggregate function packaged with topology.
SELECT topology.TopoElementArray_Agg(ARRAY[e, t] ORDER BY e, t) As tea
FROM generate_series(1, 4) As e CROSS JOIN generate_series(1, 3) As t;
{{1,1},{1,2},{1,3},{2,1},{2,2},{2,3},{3,1},{3,2},{3,3},{4,1},{4,2},{4,3}}SELECT '{{1,2,4},{3,4,5}}'::topology.topoelementarray AS tea;ERROR: value for domain topology.topoelementarray violates check constraint "dimensions"
I det här avsnittet listas Topology-funktioner för att skapa nya Topology-scheman, validera topologier och hantera TopoGeometry-kolumner
table_name i schema schema_name och avregistrerar kolumnerna från tabellen topology.layer.AddTopoGeometryColumn — Lägger till en topogeometrikolumn i en befintlig tabell, registrerar den nya kolumnen som ett lager i topology.layer och returnerar det nya layer_id.
integer AddTopoGeometryColumn(name topology_name, name schema_name, name table_name, name column_name, varchar feature_type, integer child_layer);
integer AddTopoGeometryColumn(name topology_name, regclass tab, name column_name, integer layer_id, varchar feature_type, integer child_layer);
Varje TopoGeometry-objekt hör till ett specifikt lager i en specifik topologi. Innan du skapar ett TopoGeometry-objekt måste du skapa dess TopologyLayer. Ett Topology Layer är en association av en feature-tabell med topologin. Det innehåller också information om typ och hierarki. Vi skapar ett lager med hjälp av funktionen AddTopoGeometryColumn():
Denna funktion kommer både att lägga till den begärda kolumnen i tabellen och lägga till en post i tabellen topology.layer med all angiven information.
Om du inte anger [child_layer] (eller sätter det till NULL) kommer detta lager att innehålla grundläggande TopoGeometries (sammansatta av primitiva topologielement). Annars kommer detta lager att innehålla hierarkiska TopoGeometries (sammansatta av TopoGeometries från child_layer).
När lagret har skapats (dess id returneras av funktionen AddTopoGeometryColumn) är du redo att konstruera TopoGeometry-objekt i det
Giltiga feature_typesär: PUNKT, MULTIPOINT, LINE, MULTILINE, POLYGON, MULTIPOLYGON, COLLECTION
Tillgänglighet: 1.1
This example creates the new table in the ma_topo schema. The table could be created in a different schema, in which case topology_name and schema_name would be different.
CREATE SCHEMA ma;
CREATE TABLE ma.parcels(gid serial, parcel_id varchar(20) PRIMARY KEY, address text);
SELECT topology.AddTopoGeometryColumn('ma_topo', 'ma', 'parcels', 'topo', 'POLYGON');CREATE SCHEMA ri;
CREATE TABLE ri.roads(gid serial PRIMARY KEY, road_name text);
SELECT topology.AddTopoGeometryColumn('ri_topo', 'ri', 'roads', 'topo', 'LINE');
RenameTopoGeometryColumn — Byter namn på en topogeometri-kolumn
topology.layer RenameTopoGeometryColumn(regclass layer_table, name feature_column, name new_name);
Denna funktion ändrar namnet på en befintlig TopoGeometry-kolumn och ser till att metadatainformationen om den uppdateras i enlighet med detta.
Tillgänglighet: 3.4.0
SELECT topology.RenameTopoGeometryColumn('public.parcels', 'topogeom', 'tgeom');DropTopology — Använd med försiktighet: Tar bort ett topologischema och raderar dess referens från tabellen topology.topology och referenser till tabeller i det schemat från tabellen geometry_columns.
integer DropTopology(varchar topology_schema_name);
Tar bort ett topologischema och raderar dess referens från tabellen topology.topology och referenser till tabeller i schemat från tabellen geometry_columns. Denna funktion bör användas med försiktighet, eftersom den kan förstöra data som du bryr dig om. Om schemat inte finns tar den bara bort referensposter i det namngivna schemat.
Tillgänglighet: 1.1
Cascade släpper ma_topo-schemat och tar bort alla referenser till det i topology.topology och geometry_columns.
SELECT topology.DropTopology('ma_topo');RenameTopology — Byter namn på en topologi
varchar RenameTopology(varchar old_name, varchar new_name);
Byter namn på ett topologischema och uppdaterar dess metadatapost i tabellen topology . topology.
Tillgänglighet: 3.4.0
Byt namn på en topologi från topo_stage till topo_prod.
SELECT topology.RenameTopology('topo_stage', 'topo_prod');DropTopoGeometryColumn — Tar bort kolumnen topogeometry från tabellen med namnet table_name i schema schema_name och avregistrerar kolumnerna från tabellen topology.layer.
text DropTopoGeometryColumn(varchar schema_name, varchar table_name, varchar column_name);
Tar bort kolumnen topogeometry från tabellen med namnet table_name i schema schema_name och avregistrerar kolumnerna från tabellen topology.layer. Returnerar en sammanfattning av borttagningsstatus. OBS: den sätter först alla värden till NULL innan den släpper för att kringgå kontroller av referensintegritet.
Tillgänglighet: 1.1
SELECT topology.DropTopoGeometryColumn('ma_topo', 'parcel_topo', 'topo');FixCorruptTopoGeometryColumn — Fixes topogeometry corruption caused by upgrade to postgis_topology 3.6.0 and higher
text FixCorruptTopoGeometryColumn(name layerSchema, name layerTable, name layerColumn );
When upgrading from PostGIS topology <3.6.0 to version >3.6.0+, the topogeometry column definition was changed. This caused corruption in topogeometries created before the upgrade. This function fixes this corruption in affected tables.
The function refuses to process tables with expression or partial indexes; drop or rebuild those indexes manually around the repair.
Availability: 3.6.1
Fix all topology columns
SELECT topology.FixCorruptTopoGeometryColumn(schema_name, table_name, feature_column)
FROM topology.layer;
Populate_Topology_Layer — Lägger till saknade poster i tabellen topology.layer genom att läsa metadata från topotabeller.
setof record Populate_Topology_Layer();
Lägger till saknade poster i tabellen topology.layer genom att inspektera topologibegränsningar för tabeller. Denna funktion är användbar för att åtgärda poster i topologikatalogen efter återställning av scheman med topodata.
Den returnerar en lista över skapade poster. Kolumner som returneras är schema_name, table_name, feature_column.
Tillgänglighet: 2.3.0
SELECT CreateTopology('strk_topo');
CREATE SCHEMA strk;
CREATE TABLE strk.parcels(gid serial, parcel_id varchar(20) PRIMARY KEY, address text);
SELECT topology.AddTopoGeometryColumn('strk_topo', 'strk', 'parcels', 'topo', 'POLYGON');createtopology
----------------
1
(1 row)
CREATE SCHEMA
CREATE TABLE
addtopogeometrycolumn
-----------------------
1
(1 row)This query returns no records because the feature is already registered.
SELECT * FROM topology.Populate_Topology_Layer();
(0 rows)
Rebuild the topology layer catalog.
TRUNCATE TABLE topology.layer;
TRUNCATE TABLE
SELECT * FROM topology.Populate_Topology_Layer();
schema_name | table_name | feature_column -------------+------------+---------------- strk | parcels | topo (1 row)
SELECT topology_id, layer_id,
schema_name AS sn, table_name AS tn, feature_column AS fc
FROM topology.layer;topology_id | layer_id | sn | tn | fc
-------------+----------+------+---------+------
1 | 1 | strk | parcels | topo
(1 row)TopologySummary — Tar ett topologinamn och ger sammanfattande totalsummor för olika typer av objekt i topologin.
text TopologySummary(varchar topology_schema_name);
Tar ett topologinamn och ger sammanfattande totalsummor för olika typer av objekt i topologin.
Tillgänglighet: 2.0.0
SELECT topology.TopologySummary('city_data');Topology city_data (329), SRID 4326, precision: 0 22 nodes, 24 edges, 10 faces, 29 topogeoms in 5 layers Layer 1, type Polygonal (3), 9 topogeoms Deploy: features.land_parcels.feature Layer 2, type Puntal (1), 8 topogeoms Deploy: features.traffic_signs.feature Layer 3, type Lineal (2), 8 topogeoms Deploy: features.city_streets.feature Layer 4, type Polygonal (3), 3 topogeoms Hierarchy level 1, child layer 1 Deploy: features.big_parcels.feature Layer 5, type Puntal (1), 1 topogeoms Hierarchy level 1, child layer 2 Deploy: features.big_signs.feature
ValidateTopology — Returnerar en uppsättning validatetopology_returntype-objekt som beskriver problem med topologin.
setof validatetopology_returntype ValidateTopology(varchar toponame, geometry bbox);
Returnerar en uppsättning validatetopology_returntype -objekt som beskriver problem med topologin och eventuellt begränsar kontrollen till det område som anges av parametern bbox.
Nedan visas en lista över möjliga fel, vad de betyder och vad de returnerade ID:na representerar:
| Fel | id1 | id2 | Betydelse |
|---|---|---|---|
| sammanfallande noder | Identifierare för första noden. | Identifierare för den andra noden. | Två noder har samma geometri. |
| kant korsar nod | Identifierare av kanten. | Identifierare för noden. | En kant har en nod i sitt inre. Se ST_Relate. |
| ogiltig flank | Identifierare av kanten. | En kantgeometri är ogiltig. Se ST_IsValid. | |
| kant inte enkel | Identifierare av kanten. | En kantgeometri har självskärningar. Se ST_IsSimple. | |
| kant korsar kant | Identifierare av första kanten. | Identifierare av andra kanten. | Två kanter har en inre skärningspunkt. Se ST_Relate. |
| kant start nod geometri missmatchning | Identifierare av kanten. | Identifierare för den angivna startnoden. | Geometrin för den nod som anges som startnod för en kant stämmer inte överens med den första punkten i kantgeometrin. Se ST_StartPoint. |
| kant ändnod geometri missanpassning | Identifierare av kanten. | Identifierare för den angivna slutnoden. | Geometrin för den nod som anges som slutnod för en kant stämmer inte överens med den sista punkten i kantgeometrin. Se ST_EndPoint. |
| yta utan kanter | Identifierare av den föräldralösa ytan. | Ingen kant rapporterar en befintlig yta på någon av sina sidor (left_face, right_face). | |
| ytan har inga ringar | Identifierare av den delvis definierade ytan. | Kanter som rapporterar en yta på sina sidor bildar inte en ring. | |
| ytan har fel mbr | Identifierare av yta med felaktig mbr-cache. | Minsta avgränsande rektangel för en yta stämmer inte överens med minsta avgränsande box för samlingen av kanter som rapporterar ytan på sina sidor. | |
| hål inte i annonserad yta | Signerad identifierare av en kant som identifierar ringen. Se GetRingEdges. | En ring av kanter som rapporterar en yta på sin utsida är innesluten i en annan yta. | |
| ej isolerad nod har ej innehållande_yta | Identifierare för den odefinierade noden. | En nod som rapporteras ligga på gränsen till en eller flera kanter indikerar en innehållande yta. | |
| isolerad nod har innehållande_yta | Identifierare för den odefinierade noden. | En nod som inte rapporteras som liggande på gränsen till någon kant saknar indikationen för en innehållande yta. | |
| isolerad nod har fel containing_face | Identifierare för den felaktigt presenterade noden. | En nod som inte rapporteras som liggande på gränsen till någon kant indikerar en innehållande yta som inte är den faktiska yta som innehåller den. Se GetFaceContainingPoint. | |
| ogiltig next_right_edge | Identifierare av den felrepresenterade kanten. | Signerad id för den kant som ska anges som nästa högerkant. | Den kant som anges som nästa kant som man stöter på när man går på höger sida av en kant är fel. |
| ogiltig nästa_vänstra_kant | Identifierare av den felrepresenterade kanten. | Signerad id för den kant som ska anges som nästa vänstra kant. | Den kant som anges som nästa kant som man stöter på när man går på vänster sida av en kant är fel. |
| blandad ytmärkning i ring | Signerad identifierare av en kant som identifierar ringen. Se GetRingEdges. | Kanter i en ring indikerar motstridiga ytor på gångsidan. Detta kallas också för en "Side Location Conflict". | |
| ej sluten ring | Signerad identifierare av en kant som identifierar ringen. Se GetRingEdges. | En ring av kanter som bildas genom att följa next_left_edge/next_right_edge-attributen börjar och slutar på olika noder. | |
| ytan har flera skal | Identifierare av den konturerade ytan. | Signerad identifierare av en kant som identifierar ringen. Se GetRingEdges. | Mer än en ring av kanter indikerar samma yta på dess insida. |
Tillgänglighet: 1.0.0
Förbättrad: 2.0.0 effektivare detektering av kantkorsningar och korrigeringar för falska positiva som fanns i tidigare versioner.
Ändrad: 2.2.0 värdena för id1 och id2 byttes ut mot "edge crosses node" för att stämma överens med felbeskrivningen.
Ändrad: 3.2.0 lade till valfri bbox-parameter, utför kontroller av ytmärkning och kantlänkning.
SELECT * FROM topology.ValidateTopology('ma_topo');error | id1 | id2 -------------------+-----+----- face without edges | 1 |
ValidateTopologyRelation — Returnerar information om ogiltiga topologirelationsposter
setof record ValidateTopologyRelation(varchar toponame);
Returnerar en uppsättning poster som ger information om ogiltigheter i topologins relationstabell.
Tillgänglighet: 3.2.0
ValidateTopologyPrecision — Returnerar icke-precisa toppunkter i topologin.
geometry ValidateTopologyPrecision(name toponame, geometry bbox, float8 gridSize);
Returnerar alla hörn som inte är avrundade till topologin eller given gridSize som en punktgeometri, eventuellt med begränsning av kontrollen till det område som anges av parametern bbox.
Tillgänglighet: 3.6.0
SELECT g
FROM topology.ValidateTopologyPrecision(
'city_data',
gridSize =
> 2,
bbox =
> ST_MakeEnvelope(0, 0, 20, 20)
) g;MULTIPOINT(9 6,9 14)
MakeTopologyPrecise — Fäst topologivinklar till precisionsrutnätet.
void MakeTopologyPrecise(name toponame, geometry bbox, float8 gridSize);
Snäpper alla hörn i en topologi till topologins precisionsraster eller till det raster vars storlek anges med parametern gridSize, och begränsar eventuellt operationen till de objekt som skär det område som anges med parametern bbox.
Using a gridSize larger than the smallest edge extent raises an exception rather than collapsing the edge into an empty geometry. This safeguards adjacent topological relationships by preventing precision snapping from removing primitives altogether.
![]() | |
Snapping kan göra topologin ogiltig, så det rekommenderas att du kontrollerar resultatet av operationen med ValidateTopology. |
Tillgänglighet: 3.6.0
SELECT topology.MakeTopologyPrecise(
'city_data',
gridSize =
> 2
);FindTopology — Returnerar en topologipost på olika sätt.
topology FindTopology(topogeometry topogeom);
topology FindTopology(regclass layerTable, name layerColumn);
topology FindTopology(name layerSchema, name layerTable, name layerColumn);
topology FindTopology(text topoName);
topology FindTopology(int id);
Tar en topologiidentifierare eller identifieraren för ett topologirelaterat objekt och returnerar en topology.topology-post.
Tillgänglighet: 3.2.0
SELECT name(FindTopology('features.land_parcels', 'feature'));city_data
FindLayer — Returnerar en topology.layer-post på olika sätt.
topology.layer FindLayer(topogeometry tg);
topology.layer FindLayer(regclass layer_table, name feature_column);
topology.layer FindLayer(name schema_name, name table_name, name feature_column);
topology.layer FindLayer(integer topology_id, integer layer_id);
Tar en lageridentifierare eller identifieraren för ett topologirelaterat objekt och returnerar en topology.layer-post.
Tillgänglighet: 3.2.0
SELECT layer_id(FindLayer('features.land_parcels', 'feature'));1
TotalTopologySize — Totalt diskutrymme som används av den angivna topologin, inklusive alla index och TOAST-data.
int8 TotalTopologySize(name toponame);
Tar ett topologinamn och ger det totala diskutrymmet som används av alla dess tabeller, inklusive index och TOAST-data.
Tillgänglighet: 3.6.0
SELECT topology.TopologySummary('city_data');Topology city_data (329), SRID 4326, precision: 0 22 nodes, 24 edges, 10 faces, 29 topogeoms in 5 layers Layer 1, type Polygonal (3), 9 topogeoms Deploy: features.land_parcels.feature Layer 2, type Puntal (1), 8 topogeoms Deploy: features.traffic_signs.feature Layer 3, type Lineal (2), 8 topogeoms Deploy: features.city_streets.feature Layer 4, type Polygonal (3), 3 topogeoms Hierarchy level 1, child layer 1 Deploy: features.big_parcels.feature Layer 5, type Puntal (1), 1 topogeoms Hierarchy level 1, child layer 2 Deploy: features.big_signs.feature
UpgradeTopology — Uppgraderar den angivna topologin till att stödja stora ids (int8) för topologi och primitiva ids.
void UpgradeTopology(name toponame);
Tar ett topologinamn och uppgraderar det så att det stöder stora id:n (int8) för topologi och primitiva id:n. Funktionen uppgraderar följande: - face (face_id kolumn från int4 till int8, face_id_seq från int4 till int8) - node (node_id kolumn från int4 till int8, containing_face kolumn från int4 till int8, node_id_seq från int4 till int8) - edge_data (edge_id kolumn från int4 till int8, edge_data_edge_id_seq från int4 till int8, left_face och right_face kolumner från int4 till int8, start_node och end_node kolumner från int4 till int8, next_left_edge och next_right_edge kolumner från int4 till int8) - relation (topogeo_id kolumn från int4 till int8, element_id från int4 till int8) - topologi (useslargeids kolumn satt till true)
Tillgänglighet: 3.6.0
SELECT topology.UpgradeTopology('city_data');I detta avsnitt beskrivs hantering av databasstatistik under topologibyggandet.
Att lägga till element i en topologi utlöser många databasfrågor för att hitta befintliga kanter som ska delas, lägga till noder och uppdatera kanter som ska knytas till det nya linjeverket. Därför är det bra om statistiken över data i topologitabellerna är uppdaterad.
PostGIS topologipopulation och redigeringsfunktioner uppdaterar inte statistiken automatiskt eftersom det skulle vara onödigt att uppdatera statistiken efter varje ändring i en topologi, så det är uppringarens skyldighet att ta hand om det.
![]() | |
Att statistiken som uppdateras av autovacuum INTE kommer att vara synlig för transaktioner som startade innan autovacuum-processen slutfördes, så långvariga transaktioner måste köra ANALYZE själva för att använda uppdaterad statistik. |
I detta avsnitt beskrivs topologifunktionerna för att skapa nya topologier.
CreateTopology — Skapar ett nytt topologischema och registrerar det i tabellen topology.topology.
integer CreateTopology(name topology_schema_name, integer srid, double precision prec=0, boolean hasz=false, integer topoid=0, boolean useslargeids=false);
Skapar ett nytt topologischema med namnet topology_name och registrerar det i tabellen topology . topology. Topologierna måste ha unika namn. Topologitabellerna(edge_data, face, node och relation ) skapas i schemat. Den returnerar id för topologin.
Srid är det spatiala referenssystemets SRID för topologin. Standardvärdet för SRID är -1 (okänt) om det inte anges.
Toleransen prec mäts i enheterna i det spatiala referenssystemet. Toleransen är 0 som standard.
hasz är som standard false om det inte anges.
topoid valfri explicit identifierare (möjliggör deterministisk tilldelning av topologi-id, måste vara unik)
useslargeids valfritt, standardvärde false. Om true, kommer topologin att skapas för att stödja stora id (int8) för topologi- och primitiva id.
Detta liknar SQL/MM ST_InitTopoGeo men har fler funktioner.
Tillgänglighet: 1.1
Enhanced: 2.0 added support for hasZ.
Enhanced: 3.6.0 added topoid and usesLargeIDs parameters.
Skapa ett topologischema som heter ma_topo som lagrar kanter och noder i Massachusetts State Plane-meters (SRID = 26986). Toleransen representerar 0,5 meter eftersom det spatiala referenssystemet är meterbaserat.
SELECT topology.CreateTopology('ma_topo', 26986, 0.5);Skapa en topologi för Rhode Island med namnet ri_topo i det spatiala referenssystemet State Plane-feet (SRID = 3438)
SELECT topology.CreateTopology('ri_topo', 3438) AS topoid;2
CopyTopology — Gör en kopia av en topologi (noder, kanter, ytor, lager och TopoGeometries) till ett nytt schema
integer CopyTopology(varchar existing_topology_name, varchar new_name);
Skapar en ny topologi med namnet new_name, med SRID och precision kopierade från existing_topology_name Noder, kanter och ytor i existing_topology_name kopieras till den nya topologin, liksom lager och deras associerade TopoGeometries.
![]() | |
De nya raderna i tabellen |
Tillgänglighet: 2.0.0
Gör en säkerhetskopia av en topologi som heter ma_topo.
SELECT topology.CopyTopology('ma_topo', 'ma_topo_backup');ST_InitTopoGeo — Skapar ett nytt topologischema och registrerar det i tabellen topology.topology.
text ST_InitTopoGeo(varchar topology_schema_name);
Detta är SQL-MM:s motsvarighet till CreateTopology. Den saknar alternativ för spatialt referenssystem och tolerans. den returnerar en textbeskrivning av topologins skapande, i stället för topologins id.
Tillgänglighet: 1.1
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3 Topo-Geo och Topo-Net 3: Rutinbeskrivningar: X.3.17
SELECT topology.ST_InitTopoGeo('topo_schema_to_create') AS topocreation;Topology-Geometry 'topo_schema_to_create' (id:7) created.
ST_CreateTopoGeo — Lägger till en samling geometrier till en given tom topologi och returnerar ett meddelande om det lyckas.
text ST_CreateTopoGeo(varchar atopology, geometry acollection);
Lägger till en samling geometrier till en given tom topologi och returnerar ett meddelande om det lyckas.
Användbar för att fylla i en tom topologi.
Tillgänglighet: 2.0
Denna metod implementerar SQL/MM-specifikationen. SQL-MM: Topo-Geo och Topo-Net 3: Rutinmässiga detaljer -- X.3.18
Populate the topology.
SELECT topology.ST_CreateTopoGeo( 'ri_topo', ST_GeomFromText( 'MULTILINESTRING((384744 236928,384750 236923,384769 236911,384799 236895,384811 236890,384833 236884, 384844 236882,384866 236881,384879 236883,384954 236898,385087 236932,385117 236938, 385167 236938,385203 236941,385224 236946,385233 236950,385241 236956,385254 236971, 385260 236979,385268 236999,385273 237018,385273 237037,385271 237047,385267 237057, 385225 237125,385210 237144,385192 237161,385167 237192,385162 237202,385159 237214, 385159 237227,385162 237241,385166 237256,385196 237324,385209 237345,385234 237375, 385237 237383,385238 237399,385236 237407,385227 237419,385213 237430,385193 237439, 385174 237451,385170 237455,385169 237460,385171 237475,385181 237503,385190 237521, 385200 237533,385206 237538,385213 237541,385221 237542,385235 237540,385242 237541, 385249 237544,385260 237555,385270 237570,385289 237584,385292 237589,385291 237596,385284 237630))', 3438) );
Topology ri_topo populated
Create the tables and topogeometries.
CREATE TABLE ri.roads(gid serial PRIMARY KEY, road_name text);
SELECT topology.AddTopoGeometryColumn('ri_topo', 'ri', 'roads', 'topo', 'LINE');TopoGeo_AddPoint — Lägger till en punkt i en befintlig topologi med hjälp av en tolerans och eventuellt genom att dela en befintlig kant.
bigint TopoGeo_AddPoint(varchar atopology, geometry apoint, float8 tolerance);
Lägger till en punkt till en befintlig topologi och returnerar dess identifierare. Den givna punkten snäpper till befintliga noder eller kanter inom given tolerans. En befintlig kant kan delas av den snäppta punkten.
Tillgänglighet: 2.0.0
TopoGeo_AddLineString — Lägger till en linestrings till en befintlig topologi med hjälp av en tolerans och eventuellt delning av befintliga kanter/ytor.
SETOF bigint TopoGeo_AddLineString(varchar atopology, geometry aline, float8 tolerance, int max_edges);
Adds a linestring to an existing topology and returns a set of signed edge identifiers forming it up (negative identifies mean the edge goes in the opposite direction of the input linestring).
The given line will snap to existing nodes or edges within given tolerance. Existing edges and faces may be split by the line. New nodes and faces may be added, in addition to new edges.
The returned edge identifiers may be either existing edges or newly created edges as needed to fully represent the input line as closely as possible.
The number of newly created edges (either covering space previously uncovered or resulting from split of existing edges) may be limited by the max_edges parameter.
![]() | |
When adding many lines, the load order can have a large impact on performance because each call checks the line against topology elements already loaded. In bulk workflows, adding large closed or enclosing lines before smaller contained lines can avoid expensive later splits. For loading a collection in one call, see TopoGeo_LoadGeometry. |
![]() | |
Uppdatering av statistik om topologier som laddas via denna funktion är upp till den som anropar, se maintaining statistics during topology editing and population. |
Tillgänglighet: 2.0.0
Förbättrad: 3.2.0 lade till stöd för att returnera signerad identifierare.
Enhanced: 3.7.0 added support for limiting the number of new edges created in the topology.
TopoGeo_AddPolygon — Lägger till en polygon till en befintlig topologi med hjälp av en tolerans och eventuellt delning av befintliga kanter/ytor. Returnerar ytidentifierare.
SETOF bigint TopoGeo_AddPolygon(varchar atopology, geometry apoly, float8 tolerance);
Lägger till en polygon till en befintlig topologi och returnerar en uppsättning ytidentifierare som bildar den. Gränsen för den givna polygonen kommer att snäppa till befintliga noder eller kanter inom given tolerans. Befintliga kanter och ytor kan delas av den nya polygonens gräns.
![]() | |
Uppdatering av statistik om topologier som laddas via denna funktion är upp till den som anropar, se maintaining statistics during topology editing and population. |
Tillgänglighet: 2.0.0
TopoGeo_LoadGeometry — Läs in en geometri i en befintlig topologi, snappa och dela efter behov.
void TopoGeo_LoadGeometry(varchar atopology, geometry ageom, float8 tolerance);
Läser in en geometri i en befintlig topologi. Den givna geometrin kommer att snäppa till befintliga noder eller kanter inom given tolerans. Befintliga kanter och ytor kan delas som en följd av laddningen.
![]() | |
Uppdatering av statistik om topologier som laddas via denna funktion är upp till den som anropar, se maintaining statistics during topology editing and population. |
Tillgänglighet: 3.5.0
I detta avsnitt beskrivs topologifunktioner för att lägga till, flytta, ta bort och dela kanter, ytor och noder. Alla dessa funktioner definieras av ISO SQL/MM.
alinestring till en topologi som förbinder två befintliga isolerade noder anode och anothernode och returnerar kant-ID för den nya kanten.apoint-geometrin existerar som en nod kastas ett fel. Returnerar beskrivning av förflyttning.ST_AddIsoNode — Lägger till en isolerad nod till en face i en topologi och returnerar nodeid för den nya noden. Om face är null skapas noden ändå.
bigint ST_AddIsoNode(varchar atopology, bigint aface, geometry apoint);
Lägger till en isolerad nod med punktläge apoint till en befintlig yta med faceid aface till en topologi atopologi och returnerar den nya nodens nodeid.
Om det spatiala referenssystemet (srid) för punktgeometrin inte är detsamma som topologin , apoint inte är en punktgeometri, punkten är null eller punkten skär en befintlig kant (även vid gränserna) kommer ett undantag att utlösas. Om punkten redan existerar som en nod, kommer ett undantag att kastas.
Om aface inte är null och apoint inte ligger inom ytan, utlöses ett undantag.
Tillgänglighet: 1.1
Denna metod implementerar SQL/MM-specifikationen. SQL-MM: Topo-Net Routines: X+1.3.1
ST_AddIsoEdge — Lägger till en isolerad kant definierad av geometrin alinestring till en topologi som förbinder två befintliga isolerade noder anode och anothernode och returnerar kant-ID för den nya kanten.
bigint ST_AddIsoEdge(varchar atopology, bigint anode, bigint anothernode, geometry alinestring);
Lägger till en isolerad kant definierad av geometrin alinestring till en topologi som förbinder två befintliga isolerade noder anode och anothernode och returnerar kant-ID för den nya kanten.
Om det spatiala referenssystemet (srid) för alinestring-geometrin inte är detsamma som topologin, om något av indatagumenten är null, om noderna finns i mer än en yta eller om noderna är start- eller slutnoder för en befintlig kant, så kastas ett undantag.
Om alinestringen inte ligger inom ytan för den yta som anoden och anothernoden tillhör, kastas ett undantag.
Om anoden och anothernoden inte är start- och slutpunkterna för alinestringen kastas ett undantag.
Tillgänglighet: 1.1
Denna metod implementerar SQL/MM-specifikationen. SQL-MM: Topo-Geo och Topo-Net 3: Rutinmässiga detaljer: X.3.4
ST_AddEdgeNewFaces — Lägg till en ny kant och, om den delar en yta, ta bort den ursprungliga ytan och ersätt den med två nya ytor.
bigint ST_AddEdgeNewFaces(varchar atopology, bigint anode, bigint anothernode, geometry acurve);
Lägg till en ny kant och, om den delar en yta, ta bort den ursprungliga ytan och ersätt den med två nya ytor. Returnerar id för den nyligen tillagda kanten.
Uppdaterar alla befintliga sammanfogade kanter och relationer i enlighet med detta.
Om något argument är null, de givna noderna är okända (måste redan finnas i nodtabellen i topologischemat), acurve inte är en LINESTRING, anode och anothernode inte är start- och slutpunkterna för acurve, så kastas ett fel.
Om det spatiala referenssystemet (srid) för acurve-geometrin inte är detsamma som topologin kastas ett undantag.
Tillgänglighet: 2.0
Denna metod implementerar SQL/MM-specifikationen. SQL-MM: Topo-Geo och Topo-Net 3: Rutinmässiga detaljer: X.3.12
ST_AddEdgeModFace — Lägg till en ny kant och, om den delar en yta, modifiera den ursprungliga ytan och lägg till en ny yta.
bigint ST_AddEdgeModFace(varchar atopology, bigint anode, bigint anothernode, geometry acurve);
Lägg till en ny kant och, om detta splittrar en yta, modifiera den ursprungliga ytan och lägg till en ny.
![]() | |
Om möjligt skapas den nya ytan på vänster sida av den nya kanten. Detta är inte möjligt om ytan på vänster sida måste vara universums yta (obegränsad). |
Returnerar id för den nyligen tillagda kanten.
Uppdaterar alla befintliga sammanfogade kanter och relationer i enlighet med detta.
Om något argument är null, de givna noderna är okända (måste redan finnas i nodtabellen i topologischemat), acurve inte är en LINESTRING, anode och anothernode inte är start- och slutpunkterna för acurve, så kastas ett fel.
Om det spatiala referenssystemet (srid) för acurve-geometrin inte är detsamma som topologin kastas ett undantag.
Tillgänglighet: 2.0
Denna metod implementerar SQL/MM-specifikationen. SQL-MM: Topo-Geo och Topo-Net 3: Rutinmässiga detaljer: X.3.13
ST_RemEdgeNewFace — Tar bort en kant och, om den borttagna kanten separerade två ytor, tar bort de ursprungliga ytorna och ersätter dem med en ny yta.
bigint ST_RemEdgeNewFace(varchar atopology, bigint anedge);
Tar bort en kant och, om den borttagna kanten separerade två ytor, tar bort de ursprungliga ytorna och ersätter dem med en ny yta.
Returnerar id för en nyskapad yta eller NULL, om ingen ny yta skapats. Ingen ny yta skapas när den borttagna kanten är dinglande eller isolerad eller begränsad med universums yta (vilket kan göra att universum flyter in i ytan på andra sidan).
Uppdaterar alla befintliga sammanfogade kanter och relationer i enlighet med detta.
Vägrar att ta bort en kant som deltar i definitionen av en befintlig TopoGeometry. Vägrar att läka två ytor om någon TopoGeometry definieras av endast en av dem (och inte den andra).
Om något av argumenten är null, den angivna kanten är okänd (måste redan finnas i kanttabellen i topologischemat), topologinamnet är ogiltigt, kastas ett fel.
Tillgänglighet: 2.0
Denna metod implementerar SQL/MM-specifikationen. SQL-MM: Topo-Geo och Topo-Net 3: Rutinbeskrivningar: X.3.14
ST_RemEdgeModFace — Tar bort en kant, och om kanten separerar två ytor tas den ena ytan bort och den andra ytan modifieras så att den täcker utrymmet för båda ytorna.
bigint ST_RemEdgeModFace(varchar atopology, bigint anedge);
Tar bort en kant, och om den borttagna kanten separerar två ytor tas den ena ytan bort och den andra ytan modifieras så att den täcker utrymmet för båda ytorna. Företrädesvis behålls ytan till höger, för att vara konsekvent med ST_AddEdgeModFace. Returnerar id för den yta som bevaras.
Uppdaterar alla befintliga sammanfogade kanter och relationer i enlighet med detta.
Vägrar att ta bort en kant som deltar i definitionen av en befintlig TopoGeometry. Vägrar att läka två ytor om någon TopoGeometry definieras av endast en av dem (och inte den andra).
Om något av argumenten är null, den angivna kanten är okänd (måste redan finnas i kanttabellen i topologischemat), topologinamnet är ogiltigt, kastas ett fel.
Tillgänglighet: 2.0
Denna metod implementerar SQL/MM-specifikationen. SQL-MM: Topo-Geo och Topo-Net 3: Rutinmässiga detaljer: X.3.15
ST_ChangeEdgeGeom — Ändrar formen på en kant utan att påverka topologins struktur.
text ST_ChangeEdgeGeom(varchar atopology, bigint anedge, geometry acurve);
Ändrar formen på en kant utan att påverka topologins struktur.
Om något av argumenten är null, den angivna kanten inte finns i kanttabellen i topologischemat, acurvan inte är en LINESTRING eller om modifieringen skulle ändra den underliggande topologin, så kastas ett fel.
Om det spatiala referenssystemet (srid) för acurve-geometrin inte är detsamma som topologin kastas ett undantag.
Om den nya akurvan inte är enkel, kastas ett fel.
Om förflyttningen av kanten från den gamla till den nya positionen skulle stöta på ett hinder, uppstår ett fel.
Tillgänglighet: 1.1.0
Förbättrad: 2.0.0 lägger till upprätthållande av topologisk konsistens
Denna metod implementerar SQL/MM-specifikationen. SQL-MM: Topo-Geo och Topo-Net 3: Rutinmässiga detaljer X.3.6
SELECT topology.ST_ChangeEdgeGeom(
'ma_topo',
1,
ST_GeomFromText(
'LINESTRING(227591.9 893900.4,227622.6 893844.3,227641.6 893816.6,227704.5 893778.5)',
26986)
);Edge 1 changed
ST_ModEdgeSplit — Dela en kant genom att skapa en ny nod längs en befintlig kant, modifiera den ursprungliga kanten och lägga till en ny kant.
bigint ST_ModEdgeSplit(varchar atopology, bigint anedge, geometry apoint);
Delar en kant genom att skapa en ny nod längs en befintlig kant, modifiera den ursprungliga kanten och lägga till en ny kant. Uppdaterar alla befintliga sammanfogade kanter och relationer i enlighet med detta. Returnerar identifieraren för den nyligen tillagda noden.
Tillgänglighet: 1.1
Ändrad: 2.0 - I tidigare versioner var detta felaktigt benämnt ST_ModEdgesSplit
Denna metod implementerar SQL/MM-specifikationen. SQL-MM: Topo-Geo och Topo-Net 3: Rutinmässiga detaljer: X.3.9
Add an edge to split.
SELECT topology.AddEdge('ma_topo', ST_GeomFromText('LINESTRING(227592 893910,227600 893910)', 26986)) AS edgeid;3
Split the edge with a new node.
SELECT topology.ST_ModEdgeSplit('ma_topo', 3, ST_SetSRID(ST_Point(227594, 893910), 26986)) AS node_id;7
ST_ModEdgeHeal — Läker två kanter genom att ta bort den nod som förbinder dem, modifiera den första kanten och ta bort den andra kanten. Returnerar id för den borttagna noden.
bigint ST_ModEdgeHeal(varchar atopology, bigint anedge, bigint anotheredge);
Läker två kanter genom att ta bort den nod som förbinder dem, modifiera den första kanten och ta bort den andra kanten. Returnerar id för den borttagna noden. Uppdaterar alla befintliga sammanfogade kanter och relationer i enlighet med detta.
Tillgänglighet: 2.0
Denna metod implementerar SQL/MM-specifikationen. SQL-MM: Topo-Geo och Topo-Net 3: Rutinmässiga detaljer: X.3.9
ST_NewEdgeHeal — Läker två kanter genom att ta bort noden som förbinder dem, ta bort båda kanterna och ersätta dem med en kant vars riktning är densamma som den första tillhandahållna kanten.
bigint ST_NewEdgeHeal(varchar atopology, bigint anedge, bigint anotheredge);
Läker två kanter genom att ta bort noden som förbinder dem, ta bort båda kanterna och ersätta dem med en kant vars riktning är densamma som den första angivna kanten. Returnerar id för den nya kanten som ersätter de läkta. Uppdaterar alla befintliga sammanfogade kanter och relationer i enlighet med detta.
Tillgänglighet: 2.0
Denna metod implementerar SQL/MM-specifikationen. SQL-MM: Topo-Geo och Topo-Net 3: Rutinmässiga detaljer: X.3.9
ST_MoveIsoNode — Flyttar en isolerad nod i en topologi från en punkt till en annan. Om den nya apoint-geometrin existerar som en nod kastas ett fel. Returnerar beskrivning av förflyttning.
text ST_MoveIsoNode(varchar atopology, bigint anode, geometry apoint);
Flyttar en isolerad nod i en topologi från en punkt till en annan. Om den nya apoint-geometrin finns som en nod kommer ett fel att uppstå.
Om något argument är null, apoint inte är en punkt, den befintliga noden inte är isolerad (är en start- eller slutpunkt för en befintlig kant), den nya nodpositionen skär en befintlig kant (även vid slutpunkterna) eller den nya positionen är i en annan yta (sedan 3.2.0) så kastas ett undantag.
Om det spatiala referenssystemet (srid) för punktgeometrin inte är detsamma som topologin kastas ett undantag.
Tillgänglighet: 2.0.0
Förbättrad: 3.2.0 säkerställer att nicken inte kan flyttas till en annan sida
Denna metod implementerar SQL/MM-specifikationen. SQL-MM: Topo-Net Routines: X.3.2
Add an isolated node with no face.
SELECT topology.ST_AddIsoNode('ma_topo', NULL, ST_GeomFromText('POINT(227579 893916)', 26986)) AS nodeid;7
Move the new node.
SELECT topology.ST_MoveIsoNode('ma_topo', 7, ST_GeomFromText('POINT(227579.5 893916.5)', 26986)) AS descrip;Isolated Node 7 moved to location 227579.5,893916.5
ST_NewEdgesSplit — Dela en kant genom att skapa en ny nod längs en befintlig kant, ta bort den ursprungliga kanten och ersätta den med två nya kanter. Returnerar id för den nya nod som skapats och som sammanfogar de nya kanterna.
bigint ST_NewEdgesSplit(varchar atopology, bigint anedge, geometry apoint);
Delar en kant med kant-id anedge genom att skapa en ny nod med punktläge apoint längs aktuell kant, ta bort den ursprungliga kanten och ersätta den med två nya kanter. Returnerar id för den nya nod som skapats och som sammanfogar de nya kanterna. Uppdaterar alla befintliga sammanfogade kanter och relationer i enlighet med detta.
Om det spatiala referenssystemet (srid) för punktgeometrin inte är detsamma som topologin, apoint inte är en punktgeometri, punkten är null, punkten redan finns som en nod, kanten inte motsvarar en befintlig kant eller punkten inte ligger inom kanten så kastas ett undantag.
Tillgänglighet: 1.1
Denna metod implementerar SQL/MM-specifikationen. SQL-MM: Topo-Net Routines: X.3.8
Add an edge to split.
SELECT topology.AddEdge('ma_topo', ST_GeomFromText('LINESTRING(227575 893917,227592 893900)', 26986)) AS edgeid;2
Split the new edge.
SELECT topology.ST_NewEdgesSplit('ma_topo', 2, ST_GeomFromText('POINT(227578.5 893913.5)', 26986)) AS newnodeid;6
ST_RemoveIsoNode — Tar bort en isolerad nod och returnerar en beskrivning av åtgärden. Om noden inte är isolerad (är början eller slutet på en kant), kastas ett undantag.
text ST_RemoveIsoNode(varchar atopology, bigint anode);
Tar bort en isolerad nod och returnerar en beskrivning av åtgärden. Om noden inte är isolerad (är början eller slutet på en kant), kastas ett undantag.
Tillgänglighet: 1.1
Denna metod implementerar SQL/MM-specifikationen. SQL-MM: Topo-Geo och Topo-Net 3: Rutinmässiga detaljer: X+1.3.3
Remove an isolated node with no face.
SELECT topology.ST_RemoveIsoNode('ma_topo', 7) AS result;Isolated node 7 removed
ST_RemoveIsoEdge — Tar bort en isolerad kant och returnerar en beskrivning av åtgärden. Om kanten inte är isolerad kastas ett undantag.
text ST_RemoveIsoEdge(varchar atopology, bigint anedge);
Tar bort en isolerad kant och returnerar en beskrivning av åtgärden. Om kanten inte är isolerad kastas ett undantag.
Tillgänglighet: 1.1
Denna metod implementerar SQL/MM-specifikationen. SQL-MM: Topo-Geo och Topo-Net 3: Rutinmässiga detaljer: X+1.3.3
Remove an isolated edge with no face.
SELECT topology.ST_RemoveIsoEdge('ma_topo', 7) AS result;Isolated edge 7 removed
avgränsar en yta..GetEdgeByPoint — Hittar kant-id för en kant som skär en given punkt.
bigint GetEdgeByPoint(varchar atopology, geometry apoint, float8 tol1);
Hämtar id för en kant som skär en Point.
Funktionen returnerar ett heltal (id-edge) givet en topologi, en POINT och en tolerans. Om tolerans = 0 måste punkten skära kanten.
Om en punkt inte korsar en kant returneras 0 (noll).
Om use tolerance > 0 och det finns mer än en kant nära punkten kastas ett undantag.
![]() | |
Om toleransen = 0 använder funktionen ST_Intersects, annars används ST_DWithin. |
Utförs av GEOS-modulen.
Tillgänglighet: 2.0.0
I dessa exempel används kanter som vi skapade i AddEdge
SELECT topology.GetEdgeByPoint('ma_topo', geom, 1) As with1mtol, topology.GetEdgeByPoint('ma_topo', geom, 0) As withnotol
FROM ST_GeomFromEWKT('SRID=26986;POINT(227622.6 893843)') As geom;with1mtol | withnotol
-----------+-----------
2 | 0This query errors because two or more edges are found.
SELECT topology.GetEdgeByPoint('ma_topo', geom, 1) As nearnode
FROM ST_GeomFromEWKT('SRID=26986;POINT(227591.9 893900.4)') As geom;ERROR: Two or more edges found
GetFaceByPoint — Hitta en yta som skär en given punkt.
bigint GetFaceByPoint(varchar atopology, geometry apoint, float8 tol1);
Hittar en yta som refereras av en punkt, med given tolerans.
Funktionen letar effektivt efter en yta som skär en cirkel med punkten som centrum och toleransen som radie.
Om ingen yta korsar den angivna sökplatsen returneras 0 (universell yta).
Om mer än en yta korsar den plats där frågan ställs uppstår ett undantag.
Tillgänglighet: 2.0.0
Förbättrad: 3.2.0 effektivare implementering och tydligare kontrakt, slutar fungera med ogiltiga topologier.
SELECT topology.GetFaceByPoint('ma_topo', geom, 10) As with1mtol, topology.GetFaceByPoint('ma_topo', geom, 0) As withnotol
FROM ST_GeomFromEWKT('POINT(234604.6 899382.0)') As geom;with1mtol | withnotol
-----------+-----------
1 | 0This query errors because two or more faces are found.
SELECT topology.GetFaceByPoint('ma_topo', geom, 1) As nearnode
FROM ST_GeomFromEWKT('POINT(227591.9 893900.4)') As geom;ERROR: Two or more faces found
GetFaceContainingPoint — Hittar den yta som innehåller en punkt.
bigint GetFaceContainingPoint(text atopology, geometry apoint);
Returnerar id för den yta som innehåller en punkt.
Ett undantag utlöses om punkten faller på en ytgräns.
![]() | |
Funktionen bygger på en giltig topologi med hjälp av kantlänkning och ytmärkning. |
Tillgänglighet: 3.2.0
GetNodeByPoint — Hittar nod-id för en nod vid en punktposition.
bigint GetNodeByPoint(varchar atopology, geometry apoint, float8 tol1);
Hämtar id för en nod på en punktplats.
Funktionen returnerar ett heltal (id-node) givet en topologi, en POINT och en tolerans. Om tolerans = 0 betyder det exakt intersektion, annars hämtas noden från ett intervall.
Om en punkt inte korsar en nod returneras 0 (noll).
Om use tolerance > 0 och det finns mer än en nod nära punkten kastas ett undantag.
![]() | |
Om toleransen = 0 använder funktionen ST_Intersects, annars används ST_DWithin. |
Utförs av GEOS-modulen.
Tillgänglighet: 2.0.0
I dessa exempel används kanter som vi skapade i AddEdge
SELECT topology.GetNodeByPoint('ma_topo', geom, 1) As nearnode
FROM ST_GeomFromEWKT('SRID=26986;POINT(227591.9 893900.4)') As geom;2
This query errors because the tolerance matches two or more nodes.
SELECT topology.GetNodeByPoint('ma_topo', geom, 1000) As too_much_tolerance
FROM ST_GeomFromEWKT('SRID=26986;POINT(227591.9 893900.4)') As geom;ERROR: Two or more nodes found
GetTopologyID — Returnerar id för en topologi i tabellen topology.topology givet topologins namn.
integer GetTopologyID(varchar toponame);
Returnerar id för en topologi i tabellen topology.topology givet topologins namn.
Tillgänglighet: 1.1
SELECT topology.GetTopologyID('ma_topo') AS topo_id;1
GetTopologySRID — Returnerar SRID för en topologi i tabellen topology.topology med topologins namn.
integer GetTopologyID(varchar toponame);
Returnerar det spatiala referens-id:t för en topologi i tabellen topology.topology givet namnet på topologin.
Tillgänglighet: 2.0.0
SELECT topology.GetTopologySRID('ma_topo') AS srid;4326
GetTopologyName — Returnerar namnet på en topologi (schema) givet topologins id.
varchar GetTopologyName(integer topology_id);
Returnerar topologinamnet (schemat) för en topologi från tabellen topology.topology med topologins id.
Tillgänglighet: 1.1
SELECT topology.GetTopologyName(1) AS topo_name;
ma_topo
ST_GetFaceEdges — Returnerar en uppsättning ordnade kanter som avgränsar en yta..
getfaceedges_returntype ST_GetFaceEdges(varchar atopology, bigint aface);
Returnerar en uppsättning ordnade kanter som avgränsar en yta. Varje utdata består av en sekvens och edgeid. Sekvensnummer börjar med värde 1.
Uppräkningen av varje ringkant börjar med kanten med den minsta identifieraren. Ordningen på kanterna följer en vänsterhands-regel (den bundna ytan är till vänster om varje riktad kant).
Tillgänglighet: 2.0
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3 Topo-Geo och Topo-Net 3: Rutinmässiga detaljer: X.3.5
This query returns the edges that bound face 1.
SELECT (topology.ST_GetFaceEdges('tt', 1)).*;sequence | edge
----------+------
1 | -4
2 | 5
3 | 7
4 | -6
5 | 1
6 | 2
7 | 3This query returns the sequence, edge identifier, and geometry of the edges that bound face 1. Use ST_GetFaceGeometry if only the geometry and sequence are needed.
SELECT t.seq, t.edge, geom
FROM topology.ST_GetFaceEdges('tt', 1) As t(seq, edge)
INNER JOIN tt.edge AS e ON abs(t.edge) = e.edge_id;
ST_GetFaceGeometry — Returnerar polygonen i den angivna topologin med det angivna ytans id.
geometry ST_GetFaceGeometry(varchar atopology, bigint aface);
Returnerar polygonen i den angivna topologin med det angivna ytans id. Bygger polygonen från de kanter som utgör ytan.
Tillgänglighet: 1.1
Denna metod implementerar SQL/MM-specifikationen. SQL-MM 3 Topo-Geo och Topo-Net 3: Rutinbeskrivningar: X.3.16
This query returns the WKT of the polygon added with AddFace.
SELECT topology.ST_GetFaceGeometry('ma_topo', 1) AS facegeomwkt;POLYGON((234776.9 899563.7,234896.5 899456.7,234914 899436.4,234946.6 899356.9, 234872.5 899328.7,234891 899285.4,234992.5 899145,234890.6 899069, 234755.2 899255.4,234612.7 899379.4,234776.9 899563.7))
GetRingEdges — Returnerar den ordnade uppsättningen av signerade kantidentifierare som man möter när man går på en given kantsida.
getfaceedges_returntype GetRingEdges(varchar atopology, bigint aring, integer max_edges=null);
Returnerar den ordnade uppsättningen signerade kantidentifierare som man möter när man går på en given kantsida. Varje utdata består av en sekvens och ett signerat kant-ID. Sekvensnummer börjar med värde 1.
Om du passerar ett positivt kant-ID börjar promenaden på vänster sida av motsvarande kant och följer kantriktningen. Om du passerar ett negativt kant-id startar promenaden på höger sida av den och går bakåt.
Om max_edges inte är null returneras inte fler än dessa poster av den funktionen. Detta är tänkt att vara en säkerhetsparameter vid hantering av eventuellt ogiltiga topologier.
![]() | |
Denna funktion använder metadata för kantringslänkning. |
Tillgänglighet: 2.0.0
GetNodeEdges — Returnerar en ordnad uppsättning kanter som är kopplade till den angivna noden.
getfaceedges_returntype GetNodeEdges(varchar atopology, bigint anode);
Returnerar en ordnad uppsättning kanter som är kopplade till den angivna noden. Varje utdata består av en sekvens och ett signerat kant-ID. Sekvensnummer börjar med värdet 1. En positiv kant börjar vid den givna noden. En negativ kant slutar i den givna noden. Slutna kanter kommer att visas två gånger (med båda tecknen). Ordningen är medurs med start från norrgående.
![]() | |
Denna funktion beräknar ordning i stället för att härleda från metadata och kan därför användas för att bygga kantringslänkning. |
Tillgänglighet: 2.0
FindVertexSegmentPairsBelowDistance — Find pairs of topology vertex/segment that are closer than tolerated distance
setof record FindVertexSegmentPairsBelowDistance(varchar atopology, float8 tolerance);
Returns a relation in which each tuple is a pair of vertex/segment where the vertex is NOT an endpoint of the segment but the distance between them is below the given tolerance.
Availability: 3.7
I detta avsnitt beskrivs funktionerna för att bearbeta topologier på icke-standardiserade sätt.
Polygonize — Hittar och registrerar alla ytor som definieras av topologikanter.
text Polygonize(varchar toponame);
Registrerar alla ytor som kan byggas upp av en topologis kantprimitiver.
Måltopologin antas inte innehålla några självskärande kanter.
![]() | |
Redan kända ytan känns igen, så det är säkert att anropa Polygonize flera gånger på samma topologi. |
![]() | |
Denna funktion varken använder eller ställer in fälten next_left_edge och next_right_edge i kanttabellen. |
Tillgänglighet: 2.0.0
AddNode — Lägger till en punktnod i nodtabellen i det angivna topologischemat och returnerar den nya nodens nodid. Om punkten redan finns som nod returneras det befintliga nodid.
bigint AddNode(varchar toponame, geometry apoint, boolean allowEdgeSplitting=false, boolean computeContainingFace=false);
Lägger till en punktnod i nodtabellen i det angivna topologischemat. Funktionen AddEdge lägger automatiskt till start- och slutpunkter för en kant när den anropas, så det är inte nödvändigt att uttryckligen lägga till noder för en kant.
Om en kant som korsar noden påträffas, utlöses antingen ett undantag eller så delas kanten, beroende på parametervärdet för allowEdgeSplitting.
Om computeContainingFace är true kommer en nytillagd nod att få rätt "containing face" beräknad.
![]() | |
Om |
Tillgänglighet: 2.0.0
SELECT topology.AddNode('ma_topo', ST_GeomFromText('POINT(227641.6 893816.5)', 26986)) AS nodeid;4
AddEdge — Lägger till en linestringskant i tabellen edge och associerade start- och slutpunkter i tabellen point nodes i det angivna topologischemat med hjälp av den angivna linestringsgeometrin och returnerar edgeid för den nya (eller befintliga) kanten.
bigint AddEdge(varchar toponame, geometry aline);
Lägger till en edge i edge-tabellen och associerade noder i nodes-tabellen i det angivna toponame-schemat med hjälp av den angivna geometrin för linestrings och returnerar edgeid för den nya eller befintliga posten. Den nyligen tillagda kanten har "universe"-yta på båda sidor och länkar till sig själv.
![]() | |
Om |
![]() | |
Geometrin för |
Utförs av GEOS-modulen.
![]() | |
AddEdge är föråldrad från och med 3.5.0. Använd TopoGeo_AddLineString istället. |
Tillgänglighet: 2.0.0
SELECT topology.AddEdge('ma_topo', ST_GeomFromText('LINESTRING(227575.8 893917.2,227591.9 893900.4)', 26986)) AS edgeid;1
SELECT topology.AddEdge('ma_topo', ST_GeomFromText('LINESTRING(227591.9 893900.4,227622.6 893844.2,227641.6 893816.5,227704.5 893778.5)', 26986)) AS edgeid;2
This query errors because the edge intersects an existing edge away from the endpoints.
SELECT topology.AddEdge('ma_topo', ST_GeomFromText('LINESTRING(227591.2 893900,227591.9 893900.4,227704.5 893778.5)', 26986)) AS edgeid;ERROR: Edge intersects (not on endpoints) with existing edge 1
AddFace — Registrerar en ytprimitiv till en topologi och hämtar dess identifierare.
bigint AddFace(varchar toponame, geometry apolygon, boolean force_new=false);
Registrerar en ytprimitiv till en topologi och hämtar dess identifierare.
För en nytillagd yta kommer de kanter som utgör dess gränser och de som ingår i ytan att uppdateras så att de har korrekta värden i fälten left_face och right_face. Isolerade noder som ingår i ytan kommer också att uppdateras så att de får ett korrekt värde i fältet containing_face.
![]() | |
Denna funktion varken använder eller ställer in fälten next_left_edge och next_right_edge i kanttabellen. |
Måltopologin antas vara giltig (innehåller inga självskärande kanter). Ett undantag uppstår om: Polygongränsen inte är helt definierad av befintliga kanter eller polygonen överlappar en befintlig yta.
Om apolygongeometrin redan finns som en yta, gäller följande: om force_new är false (standard) returneras den befintliga ytans id; om force_new är true tilldelas en ny id till den nyregistrerade ytan.
![]() | |
När en ny registrering av en befintlig yta utförs (force_new=true), kommer inga åtgärder att vidtas för att lösa hängande referenser till den befintliga ytan i tabellerna för edge, node och relation, och MBR-fältet i posten för den befintliga ytan kommer inte heller att uppdateras. Det är upp till den som anropar att hantera detta. |
![]() | |
|
Tillgänglighet: 2.0.0
First add the edges using generate_series as an iterator. This query only works for polygons with fewer than 10000 points because of the maximum value in generate_series.
SELECT topology.AddEdge('ma_topo', ST_MakeLine(ST_PointN(geom,i), ST_PointN(geom, i + 1) )) As edgeid
FROM (
SELECT ST_NPoints(geom) AS npt, geom
FROM (
SELECT ST_Boundary(ST_GeomFromText('POLYGON((234896.5 899456.7,234914 899436.4,234946.6 899356.9,234872.5 899328.7,
234891 899285.4,234992.5 899145, 234890.6 899069,234755.2 899255.4,
234612.7 899379.4,234776.9 899563.7,234896.5 899456.7))', 26986) ) As geom
) AS geoms
) AS facen
CROSS JOIN generate_series(1,10000) AS i
WHERE i < npt;3 4 5 6 7 8 9 10 11 12
Then add the face.
SELECT topology.AddFace(
'ma_topo',
ST_GeomFromText(
'POLYGON((234896.5 899456.7,234914 899436.4,234946.6 899356.9,234872.5 899328.7,
234891 899285.4,234992.5 899145, 234890.6 899069,234755.2 899255.4,
234612.7 899379.4,234776.9 899563.7,234896.5 899456.7))',
26986) ) As faceid;
1
ST_Simplify — Returnerar en "förenklad" geometriversion av den angivna TopoGeometry med hjälp av Douglas-Peucker-algoritmen.
geometry ST_Simplify(topogeometry tg, float8 tolerance);
Returnerar en "förenklad" geometrisk version av den angivna TopoGeometry med Douglas-Peucker-algoritmen på varje komponentkant.
![]() | |
Den returnerade geometrin kan vara icke-enkel eller icke-giltig. Att dela upp komponentkanter kan bidra till att bibehålla enkelhet/validitet. |
Utförs av GEOS-modulen.
Tillgänglighet: 2.1.0
Geometri ST_Simplify, ST_IsSimple, ST_IsValid, ST_ModEdgeSplit
RemoveUnusedPrimitives — Tar bort topologiprimitiver som inte behövs för att definiera befintliga TopoGeometry-objekt.
bigint RemoveUnusedPrimitives(text topology_name, geometry bbox);
Hittar alla primitiver (noder, kanter, ytor) som inte är absolut nödvändiga för att representera befintliga TopoGeometry-objekt och tar bort dem, med bibehållen topologigiltighet (kantlänkning, ytmärkning) och TopoGeometry-rymdbeläggning.
Inga nya primitiva identifierare skapas, utan befintliga primitiver utvidgas till att omfatta sammanslagna ytor (när kanter tas bort) eller läkta kanter (när noder tas bort).
Tillgänglighet: 3.3.0
I detta avsnitt beskrivs topologifunktionerna för att skapa nya topogeometrier.
Returnerar en topoelementarray för en uppsättning element_id, typ arrayer (topoelements).CreateTopoGeom — Skapar ett nytt topogeometriobjekt från en array av topoelement - tg_type: 1:[multi]punkt, 2:[multi]linje, 3:[multi]poly, 4:samling
topogeometry CreateTopoGeom(varchar toponame, integer tg_type, integer layer_id, topoelementarray tg_objs, bigint tg_id);
topogeometry CreateTopoGeom(varchar toponame, integer tg_type, integer layer_id);
Skapar ett topogeometriobjekt för det lager som betecknas med layer_id och registrerar det i relationstabellen i toponame-schemat.
tg_type är ett heltal: 1:[multi]punkt (punctal), 2:[multi]linje (lineal), 3:[multi]poly (areal), 4:samling. layer_id är lagrets id i tabellen topology.layer.
punktlager bildas av en uppsättning noder, linjelager bildas av en uppsättning kanter, areallager bildas av en uppsättning ytor och samlingar kan bildas av en blandning av noder, kanter och ytor.
Om du utelämnar komponentuppsättningen genereras ett tomt TopoGeometry-objekt.
Tillgänglighet: 1.1
Form from existing edges.
Skapa en topogeom i ri_topo-schema för lager 2 (våra ri_roads), av typ (2) LINE, för den första kanten (vi laddade i ST_CreateTopoGeo).
INSERT INTO ri.ri_roads(road_name, topo)
VALUES (
'Unknown',
topology.CreateTopoGeom(
'ri_topo',
2,
2,
'{{1,2}}'::topology.topoelementarray
)
);Convert an areal geometry to best guess topogeometry.
Låt oss säga att vi har geometrier som ska bildas från en samling ytor. Vi har t.ex. tabellen blockgroups och vill veta topogeometrin för varje blockgrupp. Om våra data var perfekt inriktade skulle vi kunna göra detta:
Create the topogeometry column.
SELECT topology.AddTopoGeometryColumn( 'topo_boston', 'boston', 'blockgroups', 'topo', 'POLYGON');
1
Update the column assuming everything is perfectly aligned with the edges.
UPDATE boston.blockgroups AS bg
SET topo = topology.CreateTopoGeom(
'topo_boston',
3,
1,
foo.bfaces
)
FROM (
SELECT
b.gid,
topology.TopoElementArray_Agg(ARRAY[f.face_id, 3]) AS bfaces
FROM boston.blockgroups AS b
INNER JOIN topo_boston.face AS f
ON b.geom && f.mbr
WHERE ST_Covers(
b.geom,
topology.ST_GetFaceGeometry('topo_boston', f.face_id)
)
GROUP BY b.gid
) AS foo
WHERE foo.gid = bg.gid;The world is rarely perfect, so this version allows some error. It counts a face if 50 percent of it falls within the expected block group boundary.
WITH candidate_faces AS (
SELECT
b.gid,
b.geom AS block_geom,
f.face_id,
topology.ST_GetFaceGeometry('topo_boston', f.face_id) AS face_geom
FROM boston.blockgroups AS b
INNER JOIN topo_boston.face AS f
ON b.geom && f.mbr
),
block_faces AS (
SELECT
gid,
topology.TopoElementArray_Agg(ARRAY[face_id, 3]) AS bfaces
FROM candidate_faces
WHERE ST_Covers(block_geom, face_geom)
OR (
ST_Intersects(block_geom, face_geom)
AND ST_Area(ST_Intersection(block_geom, face_geom))
> ST_Area(face_geom) * 0.5
)
GROUP BY gid
)
UPDATE boston.blockgroups AS bg
SET topo = topology.CreateTopoGeom(
'topo_boston',
3,
1,
block_faces.bfaces
)
FROM block_faces
WHERE block_faces.gid = bg.gid;To convert the topogeometry back to a denormalized geometry aligned with faces and edges, cast the topogeometry to a geometry. The resulting geometries are aligned with the TIGER street centerlines.
UPDATE boston.blockgroups SET new_geom = topo::geometry;
toTopoGeom — Konverterar en enkel geometri till en topogeometri.
topogeometry toTopoGeom(geometry geom, varchar toponame, integer layer_id, float8 tolerance=-1);
topogeometry toTopoGeom(geometry geom, topogeometry topogeom, float8 tolerance=-1);
Konverterar en enkel geometri till en TopoGeometry.
De topologiska primitiver som krävs för att representera indatageometrin läggs till i den underliggande topologin, eventuellt genom att dela upp befintliga primitiver, och de associeras med utdata TopoGeometry i relationstabellen.
Befintliga TopoGeometry-objekt (med möjligt undantag för topogeom, om det anges) kommer att behålla sina former.
When tolerance is given it will be used to snap the input geometry to existing primitives. The special value -1 (default) means use the topology precision as tolerance.
I det första formuläret skapas en ny TopoGeometry för det givna lagret(layer_id) i den givna topologin(toponame).
I den andra formen kommer de primitiver som konverteringen resulterar i att läggas till den redan existerande TopoGeometry(topogeom), och eventuellt lägga till utrymme i den slutliga formen. För att få den nya formen att helt ersätta den gamla, se clearTopoGeom.
Tillgänglighet: 2.0
Förbättrad: 2.1.0 lägger till versionen som tar en befintlig TopoGeometry.
Changed: 3.7.0 changes meaning of tolerance 0 to really mean 0 and -1 (new default) to request using the topology precision.
Detta är ett helt fristående arbetsflöde
Create the topology without allowing any tolerance.
SELECT topology.CreateTopology('topo_boston_test', 2249);Create a new table.
CREATE TABLE nei_topo(gid serial primary key, nei varchar(30));
Add a topogeometry column to the new table.
SELECT topology.AddTopoGeometryColumn('topo_boston_test', 'public', 'nei_topo', 'topo', 'MULTIPOLYGON') AS new_layer_id;1
Use the new layer identifier to populate the topogeometry column.
INSERT INTO nei_topo(nei, topo) SELECT nei, topology.toTopoGeom(geom, 'topo_boston_test', 1) FROM neighborhoods WHERE gid BETWEEN 1 and 15;
Verify what happened.
SELECT * FROM
topology.TopologySummary('topo_boston_test');Topology topo_boston_test (5), SRID 2249, precision 0 61 nodes, 87 edges, 35 faces, 15 topogeoms in 1 layers Layer 1, type Polygonal (3), 15 topogeoms Deploy: public.nei_topo.topo
Shrink all TopoGeometry polygons by 10 meters.
UPDATE nei_topo SET topo = toTopoGeom(ST_Buffer(topo, -10), clearTopoGeom(topo), 0);
Find faces that are left without any TopoGeometry reference after the shrink operation.
SELECT ST_GetFaceGeometry('topo_boston_test', f.face_id)
FROM topo_boston_test.face f
WHERE f.face_id
> 0
AND NOT EXISTS (
SELECT * FROM topo_boston_test.relation
WHERE layer_id = 1 AND element_id = f.face_id
);
TopoElementArray_Agg — Returnerar en topoelementarray för en uppsättning element_id, typ arrayer (topoelements).
topoelementarray TopoElementArray_Agg(topoelement set tefield);
Används för att skapa en TopoElementArray från en uppsättning av TopoElement.
Tillgänglighet: 2.0.0
SELECT topology.TopoElementArray_Agg(ARRAY[e, t] ORDER BY e, t) As tea FROM generate_series(1, 3) As e CROSS JOIN generate_series(1, 4) As t;
{{1,1},{1,2},{1,3},{1,4},{2,1},{2,2},{2,3},{2,4},{3,1},{3,2},{3,3},{3,4}}TopoElement — Konverterar en topogeometri till ett topoelement.
topoelement TopoElement(topogeometry topo);
Detta är ett helt fristående arbetsflöde
Return the TopoElement representation of each topogeometry.
SELECT TopoElement(topo) FROM neighborhoods;
Use a cast to aggregate topogeometries into a TopoElementArray.
SELECT topology.TopoElementArray_Agg(topo::topoelement) FROM neighborhoods GROUP BY city;
I detta avsnitt beskrivs topologifunktionerna för redigering av befintliga topogeometrier.
clearTopoGeom — Rensar innehållet i en topogeometri.
topogeometry clearTopoGeom(topogeometry topogeom);
Rensar innehållet i TopoGeometry och förvandlar det till ett tomt. Används främst i kombination med toTopoGeom för att ersätta formen på befintliga objekt och alla beroende objekt i högre hierarkiska nivåer.
Tillgänglighet: 2.1
Shrink all TopoGeometry polygons by 10 meters.
UPDATE nei_topo SET topo = toTopoGeom(ST_Buffer(topo, -10), clearTopoGeom(topo), 0);
TopoGeom_addElement — Lägger till ett element till definitionen av en TopoGeometry.
topogeometry TopoGeom_addElement(topogeometry tg, topoelement el);
Lägger till en TopoElement till definitionen av ett TopoGeometry-objekt. Det blir inget fel om elementet redan är en del av definitionen.
Tillgänglighet: 2.3
Add edge 5 to TopoGeometry tg.
UPDATE mylayer SET tg = TopoGeom_addElement(tg, '{5,2}');TopoGeom_remElement — Tar bort ett element från definitionen av en TopoGeometry.
topogeometry TopoGeom_remElement(topogeometry tg, topoelement el);
Remove face 43 from TopoGeometry tg.
UPDATE mylayer SET tg = TopoGeom_remElement(tg, '{43,3}');TopoGeom_addTopoGeom — Lägger till element i en TopoGeometry till definitionen av en annan TopoGeometry.
topogeometry TopoGeom_addTopoGeom(topogeometry tgt, topogeometry src);
Lägger till elementen i en TopoGeometry till definitionen av en annan TopoGeometry, eventuellt genom att ändra dess cachade typ (attributet type) till en samling, om det behövs för att innehålla alla element i källobjektet.
De två TopoGeometry-objekten måste definieras mot *samma* topologi och, om de är hierarkiskt definierade, måste de bestå av element i samma underordnade lager.
Tillgänglighet: 3.2
Set an overall TopoGeometry value to be composed of all elements from specific TopoGeometry values.
UPDATE mylayer SET tg_overall = TopoGeom_addTopoGeom(
TopoGeom_addTopoGeom(
clearTopoGeom(tg_overall),
tg_specific1
),
tg_specific2
);
toTopoGeom — Lägger till en geometrisk form till en befintlig topogeometri.
Se toTopoGeom.
Returnerar en topoelementarray (en array av topoelements) som innehåller de topologiska elementen och typen för den givna TopoGeometry (primitiva element).topoelement-objekt som innehåller topologiska element_id,element_type för den givna TopoGeometry (primitiva element).GetTopoGeomElementArray — Returnerar en topoelementarray (en array av topoelements) som innehåller de topologiska elementen och typen för den givna TopoGeometry (primitiva element).
topoelementarray GetTopoGeomElementArray(varchar toponame, integer layer_id, bigint tg_id);
topoelementarray GetTopoGeomElementArray(topogeometry tg);
Returnerar en TopoElementArray som innehåller de topologiska elementen och typen för den givna TopoGeometry (primitiva element). Detta liknar GetTopoGeomElements, men returnerar elementen som en array i stället för som en datamängd.
tg_id är topogeometri-id för topogeometriobjektet i topologin i det lager som betecknas med layer_id i tabellen topology.layer.
Tillgänglighet: 1.1
GetTopoGeomElements — Returnerar en uppsättning topoelement-objekt som innehåller topologiska element_id,element_type för den givna TopoGeometry (primitiva element).
setof topoelement GetTopoGeomElements(varchar toponame, integer layer_id, bigint tg_id);
setof topoelement GetTopoGeomElements(topogeometry tg);
Returnerar en uppsättning element_id,element_type (topoelements) som motsvarar primitiva topologielement TopoElement (1: noder, 2: kanter, 3: ytor) som ett givet topogeometriobjekt i toponame-schema består av.
tg_id är topogeometri-id för topogeometriobjektet i topologin i det lager som betecknas med layer_id i tabellen topology.layer.
Tillgänglighet: 2.0.0
ST_SRID — Returnerar den spatiala referensidentifieraren för en topogeometri.
integer ST_SRID(topogeometry tg);
Returns the spatial reference identifier of the topology containing the TopoGeometry.
The identifier is recorded for the topology when it is created and refers to an entry in Avsnitt 4.5, ”Spatiala referenssystem”.
Tillgänglighet: 3.2.0
Return the SRID of a TopoGeometry stored in the ri_topo topology.
SELECT topology.ST_SRID(topo) AS srid FROM ri.roads WHERE road_name = 'Unknown';
srid ------ 3438
AsGML — Returnerar GML-representationen av en topogeometri.
text AsGML(topogeometry tg);
text AsGML(topogeometry tg, text nsprefix_in);
text AsGML(topogeometry tg, regclass visitedTable);
text AsGML(topogeometry tg, regclass visitedTable, text nsprefix);
text AsGML(topogeometry tg, text nsprefix_in, integer precision, integer options);
text AsGML(topogeometry tg, text nsprefix_in, integer precision, integer options, regclass visitedTable);
text AsGML(topogeometry tg, text nsprefix_in, integer precision, integer options, regclass visitedTable, text idprefix);
text AsGML(topogeometry tg, text nsprefix_in, integer precision, integer options, regclass visitedTable, text idprefix, int gmlversion);
Returnerar GML-representationen av en topogeometri i version GML3-format. Om inget nsprefix_in anges används gml. Ange en tom sträng för nsprefix för att få en icke-kvalificerad namnrymd. Parametrarna precision (standard: 15) och options (standard 1), om de anges, skickas orörda till det underliggande anropet till ST_AsGML.
Parametern visitedTable, om den anges, används för att hålla reda på de besökta Node- och Edge-elementen så att korsreferenser (xlink:xref) kan användas i stället för att duplicera definitioner. Tabellen förväntas ha (minst) två heltalsfält: 'element_type' och 'element_id'. Den anropande användaren måste ha både läs- och skrivrättigheter för den angivna tabellen. För bästa prestanda bör ett index definieras på element_type och element_id, i nämnd ordning. Ett sådant index skapas automatiskt genom att en unik begränsning läggs till i fälten. Ett exempel:
CREATE TABLE visited ( element_type integer, element_id integer, unique(element_type, element_id) );
Parametern idprefix, om den anges, kommer att läggas till Edge- och Node-taggidentifierare.
Parametern gmlver, om den anges, kommer att skickas till den underliggande ST_AsGML. Standardvärdet är 3.
Tillgänglighet: 2.0.0
Här används den topogeometri som vi skapade i CreateTopoGeom
SELECT topology.AsGML(topo) As rdgml FROM ri.roads WHERE road_name = 'Unknown';
<gml:TopoCurve>
<gml:directedEdge>
<gml:Edge gml:id="E1">
<gml:directedNode orientation="-">
<gml:Node gml:id="N1"/>
</gml:directedNode>
<gml:directedNode
></gml:directedNode>
<gml:curveProperty>
<gml:Curve srsName="urn:ogc:def:crs:EPSG::3438">
<gml:segments>
<gml:LineStringSegment>
<gml:posList srsDimension="2"
>384744 236928 384750 236923 384769 236911 384799 236895 384811 236890
384833 236884 384844 236882 384866 236881 384879 236883 384954 236898 385087 236932 385117 236938
385167 236938 385203 236941 385224 236946 385233 236950 385241 236956 385254 236971
385260 236979 385268 236999 385273 237018 385273 237037 385271 237047 385267 237057 385225 237125
385210 237144 385192 237161 385167 237192 385162 237202 385159 237214 385159 237227 385162 237241
385166 237256 385196 237324 385209 237345 385234 237375 385237 237383 385238 237399 385236 237407
385227 237419 385213 237430 385193 237439 385174 237451 385170 237455 385169 237460 385171 237475
385181 237503 385190 237521 385200 237533 385206 237538 385213 237541 385221 237542 385235 237540 385242 237541
385249 237544 385260 237555 385270 237570 385289 237584 385292 237589 385291 237596 385284 237630</gml:posList>
</gml:LineStringSegment>
</gml:segments>
</gml:Curve>
</gml:curveProperty>
</gml:Edge>
</gml:directedEdge>
</gml:TopoCurve>
Samma övning som tidigare utan namnrymd
SELECT topology.AsGML(topo,'') As rdgml FROM ri.roads WHERE road_name = 'Unknown';
<TopoCurve>
<directedEdge>
<Edge id="E1">
<directedNode orientation="-">
<Node id="N1"/>
</directedNode>
<directedNode
></directedNode>
<curveProperty>
<Curve srsName="urn:ogc:def:crs:EPSG::3438">
<segments>
<LineStringSegment>
<posList srsDimension="2"
>384744 236928 384750 236923 384769 236911 384799 236895 384811 236890
384833 236884 384844 236882 384866 236881 384879 236883 384954 236898 385087 236932 385117 236938
385167 236938 385203 236941 385224 236946 385233 236950 385241 236956 385254 236971
385260 236979 385268 236999 385273 237018 385273 237037 385271 237047 385267 237057 385225 237125
385210 237144 385192 237161 385167 237192 385162 237202 385159 237214 385159 237227 385162 237241
385166 237256 385196 237324 385209 237345 385234 237375 385237 237383 385238 237399 385236 237407
385227 237419 385213 237430 385193 237439 385174 237451 385170 237455 385169 237460 385171 237475
385181 237503 385190 237521 385200 237533 385206 237538 385213 237541 385221 237542 385235 237540 385242 237541
385249 237544 385260 237555 385270 237570 385289 237584 385292 237589 385291 237596 385284 237630</posList>
</LineStringSegment>
</segments>
</Curve>
</curveProperty>
</Edge>
</directedEdge>
</TopoCurve>
AsTopoJSON — Returnerar TopoJSON-representationen av en topogeometri.
text AsTopoJSON(topogeometry tg, regclass edgeMapTable);
Returnerar TopoJSON-representationen av en topogeometri. Om edgeMapTable inte är null kommer den att användas som en mappning för uppslagning/lagring av kantidentifierare till bågindex. Detta för att möjliggöra en kompakt "arcs"-matris i det slutliga dokumentet.
Om tabellen anges förväntas den ha ett "arc_id"-fält av typen "serial" och ett "edge_id" av typen integer; koden kommer att fråga efter "edge_id" i tabellen, så det rekommenderas att lägga till ett index på det fältet.
![]() | |
Arc-index i TopoJSON-utdata är 0-baserade men de är 1-baserade i tabellen "edgeMapTable". |
Ett fullständigt TopoJSON-dokument måste, utöver de utdrag som returneras av denna funktion, innehålla de faktiska bågarna plus några rubriker. Se specifikationen för TopoJSON.
Tillgänglighet: 2.1.0
Förbättrad: 2.2.1 har lagt till stöd för puntal-indata
Create a temporary edge map for the TopoJSON output.
CREATE TEMP TABLE edgemap(arc_id serial, edge_id int unique);
Build the TopoJSON header, objects, arcs, and footer.
SELECT '{ "type": "Topology", "transform": { "scale": [1,1], "translate": [0,0] }, "objects": {'
UNION ALL SELECT '"' || feature_name || '": ' || AsTopoJSON(feature, 'edgemap')
FROM features.big_parcels WHERE feature_name = 'P3P4';
WITH edges AS (
SELECT m.arc_id, e.geom FROM edgemap m, city_data.edge e
WHERE e.edge_id = m.edge_id
), points AS (
SELECT arc_id, (ST_DumpPoints(geom)).* FROM edges
), compare AS (
SELECT p2.arc_id,
CASE WHEN p1.path IS NULL THEN p2.geom
ELSE ST_Translate(p2.geom, -ST_X(p1.geom), -ST_Y(p1.geom))
END AS geom
FROM points p2 LEFT OUTER JOIN points p1
ON ( p1.arc_id = p2.arc_id AND p2.path[1] = p1.path[1]+1 )
ORDER BY arc_id, p2.path
), arcsdump AS (
SELECT arc_id, (regexp_matches(ST_AsGeoJSON(geom), '\[.*\]'))[1] as t
FROM compare
), arcs AS (
SELECT arc_id, '[' || array_to_string(array_agg(t), ',') || ']' as a FROM arcsdump
GROUP BY arc_id
ORDER BY arc_id
)
SELECT '}, "arcs": [' UNION ALL
SELECT array_to_string(array_agg(a), E',\n') from arcs
UNION ALL SELECT ']}'::text as t;
{ "type": "Topology", "transform": { "scale": [1,1], "translate": [0,0] }, "objects": {
"P3P4": { "type": "MultiPolygon", "arcs": [[[-1]],[[6,5,-5,-4,-3,1]]]}
}, "arcs": [
[[25,30],[6,0],[0,10],[-14,0],[0,-10],[8,0]],
[[35,6],[0,8]],
[[35,6],[12,0]],
[[47,6],[0,8]],
[[47,14],[0,8]],
[[35,22],[12,0]],
[[35,14],[0,8]]
]}
I detta avsnitt listas de topologifunktioner som används för att kontrollera relationer mellan topogeometrier och topologiprimitiver
Equals — Returnerar true om två topogeometrier består av samma topologiprimitiver.
boolean Equals(topogeometry tg1, topogeometry tg2);
Returnerar true om två topogeometrier består av samma topologiprimitiver: ytor, kanter, noder.
![]() | |
Denna funktion stöds inte för topogeometrier som är geometrisamlingar. Den kan inte heller jämföra topogeometrier från olika topologier. |
Tillgänglighet: 1.1.0
Denna funktion stöder 3d och kommer inte att tappa z-index.
The following example uses the nei_topo table created in the toTopoGeom examples.
SELECT topology.Equals(a.topo, b.topo) FROM nei_topo AS a JOIN nei_topo AS b ON b.gid = a.gid WHERE a.gid = 1;
t
Intersects — Returnerar true om något par av primitiver från de två topogeometrierna korsar varandra.
boolean Intersects(topogeometry tg1, topogeometry tg2);
Returnerar true om något par av primitiver från de två topogeometrierna korsar varandra.
![]() | |
Denna funktion stöds inte för topogeometrier som är geometrisamlingar. Den kan inte heller jämföra topogeometrier från olika topologier. För närvarande stöds inte heller hierarkiska topogeometrier (topogeometrier som består av andra topogeometrier). |
Tillgänglighet: 1.1.0
Denna funktion stöder 3d och kommer inte att tappa z-index.
The following example uses the nei_topo table created in the toTopoGeom examples.
SELECT topology.Intersects(a.topo, b.topo) FROM nei_topo AS a JOIN nei_topo AS b ON b.gid = a.gid WHERE a.gid = 1;
t
När du har skapat topologier och kanske tillhörande topologiska lager kanske du vill exportera dem till ett filbaserat format för säkerhetskopiering eller överföring till en annan databas.
Att använda standardverktygen för dumpning / återställning av PostgreSQL är problematiskt eftersom topologier består av en uppsättning tabeller (4 för primitiver, ett godtyckligt antal för lager) och poster i metadatatabeller (topology.topology och topology.layer). Dessutom är topologiidentifierare inte univoque över databaser så att parametern för din topologi måste ändras när du återställer den.
För att förenkla export/återställning av topologier tillhandahålls ett par körbara program: pgtopo_export och pgtopo_import. Exempel på användning:
pgtopo_export dev_db topo1 | pgtopo_import topo1 | psql staging_db
Skriptet pgtopo_export tar namnet på en databas och en topologi och matar ut en dumpfil som kan användas för att importera topologin (och tillhörande lager) till en ny databas.
Som standard skriver pgtopo_export dumpfilen till standardutdata så att den kan pipas till pgtopo_import eller omdirigeras till en fil (vägrar att skriva till terminalen). Du kan ange ett filnamn för utdata med kommandoradsalternativet -f..
Som standard inkluderar pgtopo_export en dumpning av alla lager som definierats mot den givna topologin. Detta kan vara mer data än du behöver, eller kanske inte fungerar (om dina lagertabeller har komplexa beroenden), i vilket fall du kan begära att lagren hoppas över med omkopplaren --skip-layers och hantera dem separat.
Om pgtopo_export an ropas med kommandot --help (eller -h förkortat) skrivs alltid en kort användningssträng ut.
Dumpfilformatet är ett komprimerat tar-arkiv med en pgtopo_export-katalog som innehåller minst en pgtopo_dump_version-fil med information om formatversion. Från och med version 1 innehåller katalogen tabbavgränsade CSV-filer med data från de primitiva tabellerna för topologi (nod, kantdata, yta, relation), topologi- och lagerposterna som är associerade med den och (om inte --skip-layers ges) en PostgreSQL-dump i anpassat format av tabeller som rapporteras som lager i den givna topologin.
Skriptet pgtopo_import tar en topologidump i pgtopo_export-format och ett namn på den topologi som ska skapas och matar ut ett SQL-skript som rekonstruerar topologin och tillhörande lager.
Den genererade SQL-filen kommer att innehålla satser som skapar en topologi med det angivna namnet, laddar primitiva data i den, återställer och registrerar alla topologilager genom att korrekt länka alla TopoGeometry-värden till deras korrekta topologi.
Som standard läser pgtopo_import dumpningen från standardinmatningen så att den kan användas tillsammans med pgtopo_export i en pipeline. Du kan eventuellt ange ett filnamn för indata med kommandoradsalternativet -f.
Som standard inkluderar pgtopo_import i SQL-filen koden för att återställa alla lager som finns i dumpningen.
Detta kan vara oönskat eller inte fungera om din måldatabas redan har tabeller med samma namn som de i dumpningen. I så fall kan du begära att lagren hoppas över med --skip-layers och hantera dem separat (eller senare).
SQL för att endast läsa in och länka lager till en namngiven topologi kan genereras med hjälp av omkopplaren --only-layers. Detta kan vara användbart för att läsa in lager EFTER att namnkonflikterna har lösts eller för att länka lager till en annan topologi (t.ex. en spatialt förenklad version av starttopologin).
Om måltopologin redan finns och du vill att den ska tas bort i förväg kan du använda kommandot --drop-topology (sedan PostGIS-3.6.0).
I de flesta användningsfall skapar du PostGIS-raster genom att ladda befintliga rasterfiler med hjälp av den paketerade rasterladdaren raster2pgsql.
Raster2pgsql är en körbar rasterläsa inre som läsa inr GDAL-stödda rasterformat till SQL som lämpar sig för laddning i en PostGIS-rastertabell. Den kan läsa in mappar med rasterfiler samt skapa översikter över raster.
Eftersom raster2pgsql oftast kompileras som en del av PostGIS (om du inte kompilerar ditt eget GDAL-bibliotek), kommer de rastertyper som stöds av den körbara filen att vara desamma som de som kompileras i GDAL-beroendebiblioteket. För att få en lista över rastertyper som just din raster2pgsql stöder, använd -G-omkopplaren.
![]() | |
När du skapar översikter över en viss faktor från en uppsättning raster som är anpassade är det möjligt att översikterna inte är anpassade. Besök http://trac.osgeo.org/postgis/ticket/1764 för ett exempel där översikterna inte är i linje. |
Ett exempel på en session där laddaren används för att skapa en inmatningsfil och ladda upp den i 100x100 bitar kan se ut så här:
The loader assigns SRID 4326, creates an index and standard constraints, analyzes the loaded table, records source filenames, and stores the input rasters in 100 by 100 pixel tiles.
raster2pgsql -s 4326 -I -C -M -F -t 100x100 *.tif public.demelevation > elev.sql psql -d gisdb -f elev.sql
![]() | |
Om du inte anger schemat som en del av måltabellens namn kommer tabellen att skapas i standardschemat för den databas eller användare som du ansluter till. |
En konvertering och uppladdning kan göras i ett steg med hjälp av UNIX pipes:
raster2pgsql -s 4326 -I -C -M -F -t 100x100 \ *.tif public.demelevation | psql -d gisdb
Läs in raster Massachusetts statliga planmätare flygplattor i ett schema som heter aerial och skapa en fullständig vy, 2 och 4 nivå översiktstabeller, använd kopieringsläge för att infoga (ingen mellanliggande fil bara direkt till db) och -e tvingar inte allt i en transaktion (bra om du vill se data i tabeller direkt utan att vänta). Dela upp rastren i 128x128 pixelplattor och tillämpa rasterbegränsningar. Använd kopieringsläge i stället för tabellinsättning. (-F) Inkludera ett fält som heter filename för att innehålla namnet på filen som plattorna klipptes ut från.
raster2pgsql -I -C -e -Y -F -s 26986 -t 128x128 -l 2,4 \ bostonaerials2008/*.jpg aerials.boston | psql -U postgres -d gisdb -h localhost -p 5432
List the raster formats supported by this build:
raster2pgsql -G
The -G command outputs a list something like:
Available GDAL raster formats: Virtual Raster GeoTIFF National Imagery Transmission Format Raster Product Format TOC format ECRG TOC format Erdas Imagine Images (.img) CEOS SAR Image CEOS Image ... Arc/Info Export E00 GRID ZMap Plus Grid NOAA NGS Geoid Height Grids
Long options that take values also accept the --option=value spelling.
-?, --helpVisa hjälpskärm. Hjälp visas också om du inte skickar in några argument.
-G, --gdal-formatsSkriv ut de rasterformat som stöds.
-cSkapa en ny tabell och fyll i den med raster, detta är standardläget
-aLägg till raster till en befintlig tabell.
-dTa bort tabell, skapa en ny och fyll den med raster(s)
-pFörbered läge, skapa bara bordet.
--if-not-existsUse IF NOT EXISTS for table creation in -c and -p modes. When -I or --create-index is also specified, use IF NOT EXISTS for index creation too. This option cannot be used with -d. Append mode requires an explicit creation action.
The short modes are presets over explicit actions. The equivalent long options are --drop-table, --create-table, --load-data, --create-index, --add-constraints, --vacuum, --analyze, and --no-transaction. Add --if-not-exists to make active creation actions use IF NOT EXISTS. --drop-table emits DROP TABLE IF EXISTS before the selected actions. With no mode specified, the default create/load actions still apply.
-C, --add-constraintsTillämpa rasterbegränsningar - srid, pixelstorlek etc. för att säkerställa att raster är korrekt registrerat i vyn raster_columns.
-x, --no-extentDisable setting the max extent constraint. Only applied if -C or --add-constraints is also used.
-r, --regular-blockingSet the constraints (spatially unique and coverage tile) for regular blocking. Only applied if -C or --add-constraints is also used.
-s, --srid [<FROM_SRID>:]<SRID>Assign the output raster to the specified SRID. When FROM_SRID is also provided, raster2pgsql marks the input raster with FROM_SRID and emits SQL that reprojects the raster to the target SRID. If the source SRID is omitted or is zero, the raster metadata will be checked to determine an appropriate source SRID. Reprojection cannot be used with copy mode.
-b, --band BANDIndex (1-baserat) för det band som ska extraheras från rastret. För mer än ett bandindex, separera med kommatecken (,). Om inget anges kommer alla band i rastret att extraheras.
-t, --tile-size TILE_SIZESkär rastret i brickor som ska infogas, en per tabellrad. TILE_SIZE uttrycks som WIDTHxHEIGHT eller sätts till värdet "auto" för att låta inläsaren beräkna en lämplig brickstorlek med hjälp av det första rastret och tillämpas på alla raster.
-P, --padFyll på längst till höger och längst ner för att garantera att alla brickor har samma bredd och höjd.
-R, --registerRegistrera rastret som ett filsystemraster (out-db).
Endast metadata för rastret och sökvägen till rastret lagras i databasen (inte pixlarna).
-l, --overview-factor OVERVIEW_FACTORCreate overview of the raster. For more than one factor, separate with comma(,). Overview table name follows the pattern o_overview factor_table, where overview factor is a placeholder for numerical overview factor and table is replaced with the base table name. If a source raster already has an overview with matching dimensions, that overview is reused. Created overview is stored in the database and is not affected by -R. Note that your generated sql file will contain both the main table and overview tables.
-N, --nodata NODATANODATA-värde som ska användas på band utan NODATA-värde.
-f, --raster-column COLUMNAnge namn på målrasterkolumn, standard är 'rast'
-F, --filenameLägg till en kolumn med namnet på filen
-n, --filename-column COLUMNAnge namnet på kolumnen för filnamn. Innebär -F.
-q, --quotePacka in PostgreSQL-identifierare i citat.
-IAlias for --create-index.
--create-indexCreate a GiST index on the raster column at the end of this raster2pgsql run. With repeated -a append runs, create the index on the final run or after loading; add --if-not-exists to make reruns tolerate an existing index.
-MVakuumanalysera rastertabellen.
-k, --skip-nodata-checkBehåller tomma plattor och hoppar över NODATA-värdeskontroller för varje rasterband. Observera att du sparar tid på att kontrollera, men kan sluta med mycket fler skräprader i din databas och dessa skräprader markeras inte som tomma rutor.
-T, --tablespace tablespaceAnge tablespace för den nya tabellen. Observera att index (inklusive primärnyckeln) fortfarande kommer att använda standardtabellutrymmet om inte flaggan -X också används.
-X, --index-tablespace tablespaceAnge tablespace för tabellens nya index. Detta gäller för primärnyckeln och det spatiala indexet om flaggan -I används.
-Y, --copy [MAX_ROWS_PER_COPY]Använd copy-satser i stället för insert-satser. Ange valfritt max_rows_per_copy; standard 50 om inget anges.
-e, --no-transactionUtför varje villkor individuellt, använd inte en transaktion.
-E, --endian ENDIANStyr endianness för genererad binär utdata av raster; ange 0 för XDR och 1 för NDR (standard); endast NDR-utdata stöds nu
-V, --wkb-version versionAnge version av utdataformat. Standard är 0. Endast 0 stöds för närvarande.
Vid många tillfällen vill du skapa raster och rastertabeller direkt i databasen. Det finns en uppsjö av funktioner för att göra det. De allmänna stegen att följa.
Skapa en tabell med en rasterkolumn för att hålla de nya rasterposterna, vilket kan åstadkommas med:
CREATE TABLE myrasters(rid serial primary key, rast raster);
Det finns många funktioner som hjälper till med det målet. Om du skapar raster som inte är ett derivat av andra raster, bör du börja med: ST_MakeEmptyRaster, följt av ST_AddBand
Du kan också skapa raster från geometrier. För att uppnå det vill du använda ST_AsRaster kanske tillsammans med andra funktioner som ST_Union eller ST_MapAlgebraFct eller någon av familjen av andra map algebra-funktioner.
Det finns även många fler alternativ för att skapa nya rastertabeller från befintliga tabeller. Du kan t.ex. skapa en rastertabell i en annan projektion än en befintlig med hjälp av ST_Transform
När du är klar med att fylla i din tabell initialt vill du skapa ett spatialt index på rasterkolumnen med något liknande:
CREATE INDEX myrasters_rast_st_convexhull_idx ON myrasters USING gist(ST_ConvexHull(rast));
Observera användningen av ST_ConvexHull eftersom de flesta rasteroperatorer baseras på rastrernas konvexa skrov.
![]() | |
Pre-2.0-versioner av PostGIS-raster baserades på kuvertet snarare än det konvexa skrovet. För att de spatiala indexen ska fungera korrekt måste du ta bort dem och ersätta dem med index baserade på konvexa skrov. |
Tillämpa rasterbegränsningar med hjälp av AddRasterConstraints
Verktyget raster2pgsql använder GDAL för att få åtkomst till rasterdata och kan dra nytta av en viktig GDAL-funktion: möjligheten att läsa från raster som lagras på distans i molnbaserade "objektlager" (t.ex. AWS S3, Google Cloud Storage).
Effektiv användning av molnlagrade raster kräver att man använder ett "molnoptimerat" format. Det mest välkända och använda är det"molnoptimerade GeoTIFF"-formatet. Om du använder ett format som inte är molnbaserat, t.ex. JPEG eller en TIFF som inte är kaklad, får du mycket dåliga prestanda eftersom systemet måste ladda ner hela rastret varje gång det behöver komma åt en delmängd.
Först laddar du ditt raster i den molnlagring du väljer. När den har laddats kommer du att ha en URI för att komma åt den, antingen en "http"-URI eller ibland en URI som är specifik för tjänsten. (t.ex. "s3://bucket/object"). Om du vill komma åt icke-offentliga buckets måste du ange GDAL-konfigurationsalternativ för att autentisera din anslutning. Observera att det här kommandot läser från molnrastret och skriver till databasen.
AWS_ACCESS_KEY_ID=xxxxxxxxxxxxxxxxxxxx \ AWS_SECRET_ACCESS_KEY=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx \ raster2pgsql \ -s 990000 \ -t 256x256 \ -I \ -R \ /vsis3/your.bucket.com/your_file.tif \ your_table \ | psql your_db
När tabellen har laddats måste du ge databasen behörighet att läsa från fjärraster genom att ange två behörigheter, postgis.enable_outdb_rasters och postgis.gdal_enabled_drivers.
SET postgis.enable_outdb_rasters = true;
SET postgis.gdal_enabled_drivers TO 'ENABLE_ALL';
För att ändringarna ska bli bestående kan du göra dem direkt i din databas. Du måste återansluta för att uppleva de nya inställningarna.
ALTER DATABASE your_db SET postgis.enable_outdb_rasters = true;
ALTER DATABASE your_db SET postgis.gdal_enabled_drivers TO 'ENABLE_ALL';
För icke-publika raster kan du behöva ange åtkomstnycklar för att läsa från molnrastern. Samma nycklar som du använde för att skriva raster2pgsql-anropet kan ställas in för användning i databasen med postgis.gdal_vsi_options -konfigurationen. Observera att flera alternativ kan ställas in genom att mellanslag separerar nyckel=värde-paren.
SET postgis.gdal_vsi_options = 'AWS_ACCESS_KEY_ID=xxxxxxxxxxxxxxxxxxxx AWS_SECRET_ACCESS_KEY=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx';
När du har laddat data och ställt in behörigheter kan du interagera med rastertabellen som med vilken annan rastertabell som helst och använda samma funktioner. Databasen hanterar all mekanik för att ansluta till molndata när den behöver läsa pixeldata.
Det finns två rasterkatalogvyer som levereras med PostGIS. Båda vyerna använder information som är inbäddad i begränsningarna i rastertabellerna. Som ett resultat är katalogvyerna alltid konsekventa med rasterdata i tabellerna eftersom begränsningarna verkställs.
raster_columns Denna vy katalogiserar alla rastertabellkolumner i databasen.
raster_overviews Denna vy katalogiserar alla rastertabellkolumner i din databas som fungerar som översikter för en mer finkornig tabell. Tabeller av den här typen genereras när du använder växeln -l under inläsning.
Raster_columns är en katalog över alla kolumner i rastertabeller i databasen som är av typen raster. Det är en vy som utnyttjar begränsningarna i tabellerna så att informationen alltid är konsekvent även om du återställer en rastertabell från en säkerhetskopia av en annan databas. Följande kolumner finns i katalogen raster_columns.
Om du inte skapade dina tabeller med inläsningsprogrammet eller glömde att ange flaggan -C under inläsningen kan du genomdriva begränsningarna i efterhand med hjälp av AddRasterConstraints så att raster_columns-katalogen registrerar den gemensamma informationen om dina rasterplattor.
r_table_catalog Den databas som tabellen finns i. Detta kommer alltid att läsa den aktuella databasen.
r_table_schema Det databasschema som rastertabellen tillhör.
r_table_namn rastertabell
r_raster_column den kolumn i tabellen r_table_name som är av typen raster. Det finns inget i PostGIS som hindrar dig från att ha flera rasterkolumner per tabell, så det är möjligt att ha en rastertabell listad flera gånger med en annan rasterkolumn för varje.
srid Den spatiala referensidentifieraren för rastret. Bör vara en post i Avsnitt 4.5, ”Spatiala referenssystem”.
scale_x Skalningen mellan geometriska rumskoordinater och pixel. Detta är endast tillgängligt om alla tiles i rasterkolumnen har samma scale_x och denna begränsning tillämpas. Se ST_ScaleX för mer information.
scale_y Skalningen mellan geometriska rumskoordinater och pixel. Detta är endast tillgängligt om alla tiles i rasterkolumnen har samma scale_y och scale_y-begränsningen tillämpas. Se ST_ScaleY för mer information.
blocksize_x Bredden (antal pixlar tvärs över) för varje rasterplatta. Se ST_Width för mer information.
blocksize_y Bredden (antal pixlar nedåt) för varje rasterplatta. Se ST_Height för mer information.
same_alignment En boolean som är sann om alla rasterplattor har samma inriktning . Se ST_SameAlignment för mer information.
regular_blocking Om rasterkolumnen har begränsningarna spatially unique och coverage tile är värdet TRUE. Annars kommer det att vara FALSE.
num_bands Antalet band i varje platta i rasteruppsättningen. Detta är samma information som den som tillhandahålls av ST_NumBands
pixel_types En array som definierar pixeltypen för varje band. Du kommer att ha samma antal element i denna array som du har antal band. Pixel_types är en av följande definierade i ST_BandPixelType.
nodata_values En matris med tal med dubbel precision som anger nodata_värdet för varje band. Du kommer att ha samma antal element i den här matrisen som du har antal band. Dessa siffror definierar pixelvärdet för varje band som bör ignoreras för de flesta operationer. Detta är liknande information som tillhandahålls av ST_BandNoDataValue.
out_db En array med booleska flaggor som anger om rasterbanddata sparas utanför databasen. Du kommer att ha samma antal element i denna array som du har antal band.
extent Detta är omfattningen av alla rasterrader i din rasteruppsättning. Om du planerar att läsa in mer data som kommer att ändra uppsättningens utsträckning, bör du köra funktionen DropRasterConstraints före laddningen och sedan tillämpa begränsningar på nytt med AddRasterConstraints efter laddningen.
spatial_index En boolean som är sann om rasterkolumnen har ett spatialt index.
raster_overviews katalogiserar information om rastertabellkolumner som används för översikter och ytterligare information om dem som är bra att känna till när man använder översikter. Översiktstabeller katalogiseras i både raster_columns och raster_overviews eftersom de är rastertabeller i sig själva men också har ett särskilt syfte, nämligen att vara en karikatyr med lägre upplösning av en tabell med högre upplösning. Dessa genereras tillsammans med huvudrastertabellen när du använder -l-omkopplaren i rasterladdningen eller kan genereras manuellt med AddOverviewConstraints.
Översiktstabeller innehåller samma begränsningar som andra rastertabeller samt ytterligare begränsningar som endast gäller information och som är specifika för översikter.
![]() | |
Informationen i |
Två huvudskäl till översikter är:
Lågupplöst representation av kärntabellerna som ofta används för snabb utzoomning av kartor.
Det går i allmänhet snabbare att göra beräkningar på dem än på deras högupplösta förlagor eftersom det finns färre poster och varje pixel täcker ett större område. Även om beräkningarna inte är lika exakta som de högupplösta tabeller de stöder, kan de vara tillräckliga i många tumregelberäkningar.
Katalogen raster_overviews innehåller följande kolumner med information.
o_table_catalog Den databas som översiktstabellen finns i. Detta kommer alltid att läsa den aktuella databasen.
o_table_schema Det databasschema som översiktsrastertabellen tillhör.
o_table_name namn på tabell för rasteröversikt
o_raster_column rasterkolumnen i översiktstabellen.
r_table_catalog Databasen där rastertabellen för denna översiktstjänst finns. Detta kommer alltid att läsa den aktuella databasen.
r_table_schema Databasschemat för den rastertabell som denna översiktstjänst tillhör.
r_table_name rastertabell som denna översikt hanterar.
r_raster_column den rasterkolumn som denna översiktskolumn hanterar.
overview_factor - detta är pyramidnivån för översiktstabellen. Ju högre siffra desto lägre upplösning på tabellen. raster2pgsql kommer, om den får en mapp med bilder, att beräkna översikten för varje bildfil och läsa in den separat. Nivå 1 antas alltid vara originalfilen. Nivå 2 är att varje platta representerar 4 av originalet. Så om du till exempel har en mapp med bildfiler på 5000x5000 pixlar som du valt att dela upp i 125x125, kommer din bastabell för varje bildfil att ha (5000*5000)/(125*125) poster = 1600, din (l=2) o_2-tabell kommer att ha tak(1600/Power(2,2)) = 400 rader, din (l=3) o_3 kommer att ha tak(1600/Power(2,3)) = 200 rader. Om dina pixlar inte är delbara med storleken på dina brickor kommer du att få några skrotbrickor (brickor som inte är helt fyllda). Observera att varje översiktsplatta som genereras av raster2pgsql har samma antal pixlar som sin förälder, men har en lägre upplösning där varje pixel i den representerar (Power(2,overview_factor) pixlar av originalet).
Det faktum att PostGIS raster ger dig SQL-funktioner för att rendera raster i kända bildformat ger dig många alternativ för att rendera dem. Du kan till exempel använda OpenOffice / LibreOffice för rendering, vilket visas i Rendering av PostGIS Raster-grafik med LibreOffice Base Reports. Dessutom kan du använda en mängd olika språk som visas i det här avsnittet.
I det här avsnittet kommer vi att visa hur man använder PHP PostgreSQL-drivrutinen och ST_AsGDALRaster -familjen av funktioner för att mata ut band 1,2,3 av en raster till en PHP-förfrågningsström som sedan kan bäddas in i en img src html-tagg.
Exempelfrågan visar hur man kombinerar ett helt gäng rasterfunktioner tillsammans för att ta tag i alla plattor som skär en viss wgs 84 avgränsningsbox och sedan förenar med ST_Union de korsande plattorna tillsammans och returnerar alla band, transformerar till användarens angivna projektion med ST_Transform och sedan matar ut resultaten som en png med ST_AsPNG.
You would call the script with http://mywebserver/test_raster.php?srid=2249 to get the raster image in Massachusetts state plane feet.
<?php
$conn_str = 'dbname=mydb host=localhost port=5432 user=myuser password=mypwd';
$dbconn = pg_connect($conn_str);
header('Content-Type: image/png');
if (!empty($_REQUEST['srid']) && is_numeric($_REQUEST['srid'])) {
$input_srid = intval($_REQUEST['srid']);
} else {
$input_srid = 26986;
}
$sql = "SET bytea_output = 'escape';
SELECT ST_AsPNG(
ST_Transform(
ST_AddBand(
ST_Union(rast, 1),
ARRAY[ST_Union(rast, 2), ST_Union(rast, 3)]
),
$input_srid
)
) AS new_rast
FROM aerials.boston
WHERE ST_Intersects(
rast,
ST_Transform(
ST_MakeEnvelope(-71.1217, 42.227, -71.1210, 42.218, 4326),
26986
)
)";
$result = pg_query($sql);
$row = pg_fetch_row($result);
pg_free_result($result);
if ($row === false) return;
echo pg_unescape_bytea($row[0]);
?>
In this section, we'll demonstrate how to use Npgsql PostgreSQL .NET driver and the ST_AsGDALRaster family of functions to output band 1,2,3 of a raster to the HTTP response stream so it can be embedded in an img tag.
Du behöver npgsql .NET PostgreSQL-drivrutinen för den här övningen som du kan få det senaste från http://npgsql.projects.postgresql.org/. Ladda bara ner det senaste och släpp in i din ASP.NET bin-mapp så är du redo att gå.
Exempelfrågan visar hur man kombinerar ett helt gäng rasterfunktioner tillsammans för att ta tag i alla plattor som skär en viss wgs 84 avgränsningsbox och sedan förenar med ST_Union de korsande plattorna tillsammans och returnerar alla band, transformerar till användarens angivna projektion med ST_Transform och sedan matar ut resultaten som en png med ST_AsPNG.
Detta är samma exempel som Avsnitt 10.3.1, ”PHP-exempel Utdata med ST_AsPNG i kombination med andra rasterfunktioner” men implementerat i C#.
You would call the handler with http://mywebserver/TestRaster.ashx?srid=2249 to get the raster image in Massachusetts state plane feet.
web.config connection string section:
<connectionStrings>
<add name="DSN"
connectionString="server=localhost;database=mydb;Port=5432;User Id=myuser;password=mypwd"/>
</connectionStrings>
Code for TestRaster.ashx:
<%@ WebHandler Language="C#" Class="TestRaster" %>
using System;
using System.Data;
using System.Web;
using Npgsql;
public class TestRaster : IHttpHandler
{
public void ProcessRequest(HttpContext context)
{
context.Response.ContentType = "image/png";
context.Response.BinaryWrite(GetResults(context));
}
public bool IsReusable {
get { return false; }
}
public byte[] GetResults(HttpContext context)
{
byte[] result = null;
NpgsqlCommand command;
string sql = null;
int input_srid = 26986;
try {
string connectionString = System.Configuration.ConfigurationManager
.ConnectionStrings["DSN"].ConnectionString;
using (NpgsqlConnection conn = new NpgsqlConnection(connectionString)) {
conn.Open();
if (context.Request["srid"] != null)
{
input_srid = Convert.ToInt32(context.Request["srid"]);
}
sql = @"SELECT ST_AsPNG(
ST_Transform(
ST_AddBand(
ST_Union(rast, 1),
ARRAY[ST_Union(rast, 2), ST_Union(rast, 3)]
),
:input_srid
)
) As new_rast
FROM aerials.boston
WHERE ST_Intersects(
rast,
ST_Transform(
ST_MakeEnvelope(
-71.1217, 42.227,
-71.1210, 42.218,
4326
),
26986
)
)";
command = new NpgsqlCommand(sql, conn);
command.Parameters.Add(new NpgsqlParameter("input_srid", input_srid));
result = (byte[]) command.ExecuteScalar();
conn.Close();
}
}
catch (Exception ex)
{
result = null;
context.Response.Write(ex.Message.Trim());
}
return result;
}
}
Detta är en enkel java-konsolapp som tar en fråga som returnerar en bild och matar ut till den angivna filen.
Du kan ladda ner de senaste PostgreSQL JDBC-drivrutinerna från http://jdbc.postgresql.org/download.html
You can compile the following code with commands like:
CLASSPATH=".:../postgresql.jar" javac SaveQueryImage.java jar cfm SaveQueryImage.jar Manifest.txt *.class
And call it from the command line with something like:
java -jar SaveQueryImage.jar \ "SELECT ST_AsPNG(ST_AsRaster(ST_Buffer(ST_Point(1, 5), 10, 'quad_segs=2'), 150, 150, '8BUI', 100));" \ "test.png"
Manifest.txt:
Class-Path: postgresql-9.0-801.jdbc4.jar Main-Class: SaveQueryImage
Code for SaveQueryImage.java:
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.io.*;
public class SaveQueryImage {
public static void main(String[] argv) {
System.out.println("Checking if Driver is registered with DriverManager.");
try {
//java.sql.DriverManager.registerDriver (new org.postgresql.Driver());
Class.forName("org.postgresql.Driver");
}
catch (ClassNotFoundException cnfe) {
System.out.println("Couldn't find the driver!");
cnfe.printStackTrace();
System.exit(1);
}
Connection conn = null;
try {
conn = DriverManager.getConnection("jdbc:postgresql://localhost:5432/mydb", "myuser", "mypwd");
conn.setAutoCommit(false);
PreparedStatement sGetImg = conn.prepareStatement(argv[0]);
ResultSet rs = sGetImg.executeQuery();
FileOutputStream fout;
try
{
rs.next();
/** Output to file name requested by user **/
fout = new FileOutputStream(new File(argv[1]) );
fout.write(rs.getBytes(1));
fout.close();
}
catch(Exception e)
{
System.out.println("Can't create file");
e.printStackTrace();
}
rs.close();
sGetImg.close();
conn.close();
}
catch (SQLException se) {
System.out.println("Couldn't connect: print out a stack trace and exit.");
se.printStackTrace();
System.exit(1);
}
}
}Detta är en plpython-lagrad funktion som skapar en fil i serverkatalogen för varje post. Kräver att du har plpython installerat. Bör fungera bra med både plpythonu och plpython3u.
CREATE OR REPLACE FUNCTION write_file (param_bytes bytea, param_filepath text) RETURNS text AS $$ f = open(param_filepath, 'wb+') f.write(param_bytes) return param_filepath $$ LANGUAGE plpythonu;
Write out 5 images to the PostgreSQL server in varying sizes. The PostgreSQL daemon account needs write access to the folder; this echoes back the file names created.
SELECT write_file(
ST_AsPNG(
ST_AsRaster(
ST_Buffer(ST_Point(1, 5), j * 5, 'quad_segs=2'),
150 * j,
150 * j,
'8BUI',
100
)
),
'C:/temp/slices' || j || '.png'
)
FROM generate_series(1, 5) AS j;write_file --------------------- C:/temp/slices1.png C:/temp/slices2.png C:/temp/slices3.png C:/temp/slices4.png C:/temp/slices5.png
Sadly PSQL doesn't have easy to use built-in functionality for outputting binaries. This is a bit of a hack that piggy backs on PostgreSQL somewhat legacy large object support. To use it, first launch your psql command line connected to your database.
Till skillnad från pythonmetoden skapas filen här på din lokala dator.
SELECT
oid,
lowrite(lo_open(oid, 131072), png) AS num_bytes
FROM (VALUES (
lo_create(0),
ST_AsPNG((SELECT rast FROM aerials.boston WHERE rid = 1))
)) AS v(oid, png);oid | num_bytes ---------+----------- 2630819 | 74860
Note the large object OID and export it to a file on your local computer, replacing the example path with the desired file path.
\lo_export 2630819 'C:/temp/aerial_samp.png'
This deletes the file from large object storage in the database.
SELECT lo_unlink(2630819);
raster är en PostGIS-typ för lagring och analys av rasterdata.
För att läsa in raster från rasterfiler, se Avsnitt 10.1, ”Läs in och skapa raster”
I några exempel i denna referens används en rastertabell med dummy-data som skapats med följande kod:
CREATE TABLE dummy_rast(rid integer, rast raster);
INSERT INTO dummy_rast(rid, rast)
VALUES (1,
('01' -- little endian (uint8 ndr)
||
'0000' -- version (uint16 0)
||
'0000' -- nBands (uint16 0)
||
'0000000000000040' -- scaleX (float64 2)
||
'0000000000000840' -- scaleY (float64 3)
||
'000000000000E03F' -- ipX (float64 0.5)
||
'000000000000E03F' -- ipY (float64 0.5)
||
'0000000000000000' -- skewX (float64 0)
||
'0000000000000000' -- skewY (float64 0)
||
'00000000' -- SRID (int32 0)
||
'0A00' -- width (uint16 10)
||
'1400' -- height (uint16 20)
)::raster
),
-- Raster: 5 x 5 pixels, 3 bands, PT_8BUI pixel type, NODATA = 0
(2, ('01000003009A9999999999A93F9A9999999999A9BF000000E02B274A' ||
'41000000007719564100000000000000000000000000000000FFFFFFFF050005000400FDFEFDFEFEFDFEFEFDF9FAFEF' ||
'EFCF9FBFDFEFEFDFCFAFEFEFE04004E627AADD16076B4F9FE6370A9F5FE59637AB0E54F58617087040046566487A1506CA2E3FA5A6CAFFBFE4D566DA4CB3E454C5665')::raster);Funktionerna nedan är sådana som en användare av PostGIS Raster sannolikt kommer att behöva. Det finns andra stödfunktioner för raster som inte är av intresse för en allmän användare.
Detta avsnitt listar PostgreSQL-datatyper som specifikt skapats för att stödja rasterfunktionalitet.
geomval — En spatial datatyp med två fält - geom (som innehåller ett geometriobjekt) och val (som innehåller ett pixelvärde med dubbel precision från ett rasterband).
geomval är en sammansatt datatyp som består av ett geometriobjekt som refereras av fältet .geom och val, ett värde med dubbel precision som representerar pixelvärdet på en viss geometrisk plats i ett rasterband. Den används av funktionerna ST_DumpAsPolygon och Raster intersection som en utdatatyp för att explodera ett rasterband till geometripolygoner.
addbandarg — En sammansatt typ som används som indata till funktionen ST_AddBand och som definierar det nya bandets attribut och initiala värde.
En sammansatt typ som används som indata till funktionen ST_AddBand och som definierar det nya bandets attribut och initiala värde.
| Field | Type | Description |
|---|---|---|
index | integer | 1-baserat värde som anger positionen där det nya bandet ska läggas till bland rastrets band. Om NULL, kommer det nya bandet att läggas till i slutet av rastrets band. |
pixeltype | text | Pixel type of the new band. One of the pixel types described in ST_BandPixelType. |
initialvalue | double precision | Initial value that all pixels of the new band will be set to. |
nodataval | double precision | NODATA-värde för det nya bandet. Om NULL, kommer det nya bandet inte att tilldelas något NODATA-värde. |
rastbandarg — En sammansatt typ som kan användas när man behöver uttrycka ett raster och ett bandindex för detta raster.
En sammansatt typ som kan användas när man behöver uttrycka ett raster och ett bandindex för detta raster.
| Field | Type | Description |
|---|---|---|
rast | raster | The raster in question. |
nband | integer | 1-based value indicating the raster band. |
raster — spatial rasterdatatyp.
raster är en spatial datatyp som används för att representera rasterdata som de som importeras från JPEGs, TIFFs, PNGs, digitala höjdmodeller. Varje raster har 1 eller flera band som vart och ett har en uppsättning pixelvärden. Raster kan georefereras.
![]() | |
Kräver att PostGIS är kompilerat med GDAL-stöd. För närvarande kan raster implicit konverteras till geometrityp, men konverteringen returnerar ST_ConvexHull för rastret. Denna automatiska casting kan tas bort inom en snar framtid, så lita inte på det. |
I detta avsnitt listas de automatiska såväl som explicita kast som är tillåtna för denna datatyp
| Kasta till | Beteende |
|---|---|
| geometri | automatisk |
reclassarg — En sammansatt typ som används som indata till funktionen ST_Reclass och som definierar beteendet vid omklassificering.
En sammansatt typ som används som indata till funktionen ST_Reclass som definierar beteendet vid omklassificering.
| Field | Type | Description |
|---|---|---|
nband | integer | Bandnumret på bandet för att omklassificera. |
reclassexpr | text | Comma-delimited range:map_range mappings that define how old band values map to new band values. |
pixeltype | text | One of defined pixel types as described in ST_BandPixelType. |
nodataval | double precision | Värde som ska behandlas som ingen data. För bildutdata som stöder transparens kommer dessa att vara tomma. |
The reclassexpr range delimiters mean: ( greater than, ) less than, ] less than or equal, and [ greater than or equal.
[a-b] means a <= x <= b.
(a-b] means a < x <= b.
[a-b) means a <= x < b.
(a-b) means a < x < b.
Opening-parenthesis notation is optional, so a-b means the same as (a-b).
Reclassify band 2 as an 8BUI where 255 is nodata value.
SELECT ROW(2, '0-100:1-10, 101-500:11-150,501 - 10000: 151-254', '8BUI', 255)::reclassarg;
Reclassify band 1 as an 1BB and no nodata value defined.
SELECT ROW(1, '0-100]:0, (100-255:1', '1BB', NULL)::reclassarg;
summarystats — En sammansatt typ som returneras av funktionerna ST_SummaryStats och ST_SummaryStatsAgg.
En sammansatt typ som returneras av funktionerna ST_SummaryStats och ST_SummaryStatsAgg.
Antal pixlar som räknats för den sammanfattande statistiken.
Summan av alla räknade pixelvärden.
Aritmetiskt medelvärde av alla räknade pixelvärden.
Standardavvikelse för alla räknade pixelvärden.
Minimivärde för räknade pixelvärden.
Maximalt värde för räknade pixelvärden.
unionarg — En sammansatt typ som används som indata till ST_Union-funktionen och som definierar de band som ska bearbetas och beteendet hos UNION-operationen.
En sammansatt typ som används som indata till ST_Union-funktionen och som definierar de band som ska bearbetas och beteendet hos UNION-operationen.
| Field | Type | Description |
|---|---|---|
nband | integer | 1-baserat värde som anger bandet för varje inmatningsraster som ska bearbetas. |
uniontype | text | Type of union operation. One of the types described in ST_Union. |
AddRasterConstraints — Lägger till rasterbegränsningar till en laddad rastertabell för en specifik kolumn som begränsar spatial ref, skalning, blockstorlek, inriktning, band, bandtyp och en flagga för att ange om rasterkolumnen blockeras regelbundet. Tabellen måste vara laddad med data för att begränsningarna ska kunna härledas. Returnerar true om begränsningsinställningen har utförts och utfärdar ett meddelande i annat fall.
boolean AddRasterConstraints(name rasttable, name rastcolumn, boolean srid=true, boolean scale_x=true, boolean scale_y=true, boolean blocksize_x=true, boolean blocksize_y=true, boolean same_alignment=true, boolean regular_blocking=false, boolean num_bands=true , boolean pixel_types=true , boolean nodata_values=true , boolean out_db=true , boolean extent=true );
boolean AddRasterConstraints(name rasttable, name rastcolumn, text[] VARIADIC constraints);
boolean AddRasterConstraints(name rastschema, name rasttable, name rastcolumn, text[] VARIADIC constraints);
boolean AddRasterConstraints(name rastschema, name rasttable, name rastcolumn, boolean srid=true, boolean scale_x=true, boolean scale_y=true, boolean blocksize_x=true, boolean blocksize_y=true, boolean same_alignment=true, boolean regular_blocking=false, boolean num_bands=true, boolean pixel_types=true, boolean nodata_values=true , boolean out_db=true , boolean extent=true );
Skapar begränsningar för en rasterkolumn som används för att visa information i rasterkatalogen raster_columns. Rastschema är namnet på det tabellschema som tabellen finns i. Srid måste vara en heltalsreferens till en post i tabellen SPATIAL_REF_SYS.
raster2pgsql-laddaren använder denna funktion för att registrera rastertabeller
Giltiga namn på begränsningar som kan anges: se Avsnitt 10.2.1, ”Rasterkolumner Katalog” för mer information.
blocksize ställer in både X- och Y-blocksize
blocksize_x ställer in X-tile (bredd i pixlar för varje tile)
blocksize_y anger Y-platta (höjd i pixlar för varje platta)
extent beräknar hela tabellens utsträckning och tillämpar begränsningen att alla raster måste ligga inom denna utsträckning
num_bands antal band
pixel_types läser matris med pixeltyper för varje band säkerställer att alla band n har samma pixeltyp
regular_blocking anger spatialt unika (inga två raster kan vara spatialt lika) och täckningsplatta (raster är anpassat till en täckning) begränsningar
same_alignment säkerställer att de alla har samma inriktning, vilket innebär att alla två brickor du jämför kommer att returnera sant för. Hänvisa till ST_SameAlignment.
srid säkerställer att alla har samma srid
Mer -- alla som anges som indata i ovanstående funktioner
![]() | |
Denna funktion härleder begränsningarna från de data som redan finns i tabellen. För att den ska fungera måste du därför först skapa rasterkolumnen och sedan läsa in den med data. |
![]() | |
Om du behöver läsa in mer data i dina tabeller efter att du redan har tillämpat begränsningar kan du köra DropRasterConstraints om omfattningen av dina data har ändrats. |
Tillgänglighet: 2.0.0
Apply all possible constraints on column based on data.
Verify the raster table is registered correctly in the raster_columns view.
CREATE TABLE myrasters(rid SERIAL primary key, rast raster);
INSERT INTO myrasters(rast)
SELECT ST_AddBand(ST_MakeEmptyRaster(1000, 1000, 0.3, -0.3, 2, 2, 0, 0, 4326), 1, '8BSI'::text, -129, NULL);
SELECT AddRasterConstraints('myrasters'::name, 'rast'::name);
SELECT srid, scale_x, scale_y, blocksize_x, blocksize_y, num_bands, pixel_types, nodata_values
FROM raster_columns
WHERE r_table_name = 'myrasters';srid | scale_x | scale_y | blocksize_x | blocksize_y | num_bands | pixel_types| nodata_values
------+---------+---------+-------------+-------------+-----------+-------------+---------------
4326 | 2 | 2 | 1000 | 1000 | 1 | {8BSI} | {0}Apply single constraint.
CREATE TABLE public.myrasters2(rid SERIAL primary key, rast raster);
INSERT INTO myrasters2(rast)
SELECT ST_AddBand(ST_MakeEmptyRaster(1000, 1000, 0.3, -0.3, 2, 2, 0, 0, 4326), 1, '8BSI'::text, -129, NULL);
SELECT AddRasterConstraints('public'::name, 'myrasters2'::name, 'rast'::name, 'regular_blocking', 'blocksize');NOTICE: Adding regular blocking constraint NOTICE: Adding blocksize-X constraint NOTICE: Adding blocksize-Y constraint
DropRasterConstraints — Tar bort PostGIS-rasterbegränsningar som hänvisar till en rastertabellkolumn. Användbart om du behöver ladda om data eller uppdatera dina rasterkolumndata.
boolean DropRasterConstraints(name rasttable, name rastcolumn, boolean srid, boolean scale_x, boolean scale_y, boolean blocksize_x, boolean blocksize_y, boolean same_alignment, boolean regular_blocking, boolean num_bands=true, boolean pixel_types=true, boolean nodata_values=true, boolean out_db=true , boolean extent=true);
boolean DropRasterConstraints(name rastschema, name rasttable, name rastcolumn, boolean srid=true, boolean scale_x=true, boolean scale_y=true, boolean blocksize_x=true, boolean blocksize_y=true, boolean same_alignment=true, boolean regular_blocking=false, boolean num_bands=true, boolean pixel_types=true, boolean nodata_values=true, boolean out_db=true , boolean extent=true);
boolean DropRasterConstraints(name rastschema, name rasttable, name rastcolumn, text[] constraints);
Tar bort PostGIS-rasterbegränsningar som hänvisar till en rastertabellkolumn som lades till av AddRasterConstraints. Användbart om du behöver läsa in mer data eller uppdatera dina rasterkolumndata. Du behöver inte göra detta om du vill bli av med en rastertabell eller en rasterkolumn.
To drop a raster table use standard SQL: DROP TABLE mytable.
To drop just a raster column and leave the rest of the table, use standard SQL: ALTER TABLE mytable DROP COLUMN rast.
kommer tabellen att försvinna från katalogen raster_columns om kolumnen eller tabellen tas bort. Men om endast begränsningarna tas bort kommer rasterkolumnen fortfarande att listas i katalogen raster_columns, men det kommer inte att finnas någon annan information om den förutom kolumnnamnet och tabellen.
Tillgänglighet: 2.0.0
SELECT DropRasterConstraints ('myrasters', 'rast');droprasterconstraints ----------------------- t (1 row)
Verify change in raster_columns.
SELECT srid, scale_x, scale_y, blocksize_x, blocksize_y, num_bands, pixel_types, nodata_values
FROM raster_columns
WHERE r_table_name = 'myrasters';srid | scale_x | scale_y | blocksize_x | blocksize_y | num_bands | pixel_types| nodata_values
------+---------+---------+-------------+-------------+-----------+-------------+---------------
0 | | | | | | |AddOverviewConstraints — Märk en rasterkolumn som en översikt av en annan.
boolean AddOverviewConstraints(name ovschema, name ovtable, name ovcolumn, name refschema, name reftable, name refcolumn, int ovfactor);
boolean AddOverviewConstraints(name ovtable, name ovcolumn, name reftable, name refcolumn, int ovfactor);
Lägger till begränsningar för en rasterkolumn som används för att visa information i rasterkatalogen raster_overviews.
Parametern ovfactor representerar skalmultiplikatorn i översiktskolumnen: högre översiktsfaktorer ger lägre upplösning.
När parametrarna ovschema och refschema utelämnas används den första tabellen som hittas när sökvägen skannas.
Tillgänglighet: 2.0.0
Verify the raster table is registered correctly in the raster_overviews view.
CREATE TABLE res1 AS SELECT
ST_AddBand(ST_MakeEmptyRaster(1000, 1000, 0, 0, 2),
1, '8BSI'::text, -129, NULL
) r1;
CREATE TABLE res2 AS SELECT
ST_AddBand(ST_MakeEmptyRaster(500, 500, 0, 0, 4),
1, '8BSI'::text, -129, NULL
) r2;
SELECT AddOverviewConstraints('res2', 'r2', 'res1', 'r1', 2);
SELECT o_table_name ot, o_raster_column oc,
r_table_name rt, r_raster_column rc,
overview_factor f
FROM raster_overviews WHERE o_table_name = 'res2';ot | oc | rt | rc | f ------+----+------+----+--- res2 | r2 | res1 | r1 | 2 (1 row)
DropOverviewConstraints — Avmarkera en rasterkolumn från att vara en översikt av en annan.
boolean DropOverviewConstraints(name ovschema, name ovtable, name ovcolumn);
boolean DropOverviewConstraints(name ovtable, name ovcolumn);
Ta bort de begränsningar som används för att visa en rasterkolumn som en översikt över en annan i rasterkatalogen raster_overviews från en rasterkolumn.
Om parametern ovschema utelämnas används den första tabellen som hittas när sökvägen skannas.
Tillgänglighet: 2.0.0
PostGIS_GDAL_Version — Rapporterar den version av GDAL-biblioteket som används av PostGIS.
text PostGIS_GDAL_Version();
Rapporterar den version av GDAL-biblioteket som används av PostGIS. Kommer också att kontrollera och rapportera om GDAL kan hitta sina datafiler.
SELECT PostGIS_GDAL_Version();
GDAL 1.11dev, released 2013/04/13
PostGIS_Raster_Lib_Build_Date — Rapporterar hela rasterbibliotekets byggnadsdatum.
text PostGIS_Raster_Lib_Build_Date();
Rapporterar rastrets byggnadsdatum
SELECT PostGIS_Raster_Lib_Build_Date();
2010-04-28 21:15:10
PostGIS_Raster_Lib_Version — Rapporterar fullständig information om rasterversion och byggkonfiguration.
text PostGIS_Raster_Lib_Version();
Rapporterar fullständig information om rasterversion och byggkonfiguration.
SELECT PostGIS_Raster_Lib_Version();
2.0.0
ST_GDALDrivers — Returnerar en lista över rasterformat som stöds av PostGIS via GDAL. Endast de format med can_write=True kan användas av ST_AsGDALRaster
setof record ST_GDALDrivers(integer OUT idx, text OUT short_name, text OUT long_name, text OUT can_read, text OUT can_write, text OUT create_options);
Returnerar en lista med rasterformat short_name,long_name och skapande alternativ för varje format som stöds av GDAL. Använd short_name som indata i format-parametern för ST_AsGDALRaster. Alternativen varierar beroende på vilka drivrutiner som libgdal kompilerades med. create_options returnerar en xml-formaterad uppsättning CreationOptionList/Option som består av namn och valfri type, description och uppsättning VALUE för varje skaparalternativ för den specifika drivrutinen.
Ändrad: 2.5.0 - lägg till kolumnerna can_read och can_write.
Ändrad: 2.0.6, 2.1.3 - som standard är inga drivrutiner aktiverade, såvida inte GUC eller miljövariabeln gdal_enabled_drivers är inställd.
Tillgänglighet: 2.0.0 - kräver GDAL >= 1.6.0.
List of Drivers.
SET postgis.gdal_enabled_drivers = 'ENABLE_ALL'; SELECT short_name, long_name, can_write FROM ST_GDALDrivers() ORDER BY short_name;
short_name | long_name | can_write -----------------+-------------------------------------------------------------+----------- AAIGrid | Arc/Info ASCII Grid | t ACE2 | ACE2 | f ADRG | ARC Digitized Raster Graphics | f AIG | Arc/Info Binary Grid | f AirSAR | AirSAR Polarimetric Image | f ARG | Azavea Raster Grid format | t BAG | Bathymetry Attributed Grid | f BIGGIF | Graphics Interchange Format (.gif) | f BLX | Magellan topo (.blx) | t BMP | MS Windows Device Independent Bitmap | f BSB | Maptech BSB Nautical Charts | f PAux | PCI .aux Labelled | f PCIDSK | PCIDSK Database File | f PCRaster | PCRaster Raster File | f PDF | Geospatial PDF | f PDS | NASA Planetary Data System | f PDS4 | NASA Planetary Data System 4 | t PLMOSAIC | Planet Labs Mosaics API | f PLSCENES | Planet Labs Scenes API | f PNG | Portable Network Graphics | t PNM | Portable Pixmap Format (netpbm) | f PRF | Racurs PHOTOMOD PRF | f R | R Object Data Store | t Rasterlite | Rasterlite | t RDA | DigitalGlobe Raster Data Access driver | f RIK | Swedish Grid RIK (.rik) | f RMF | Raster Matrix Format | f ROI_PAC | ROI_PAC raster | f RPFTOC | Raster Product Format TOC format | f RRASTER | R Raster | f RS2 | RadarSat 2 XML Product | f RST | Idrisi Raster A.1 | t SAFE | Sentinel-1 SAR SAFE Product | f SAGA | SAGA GIS Binary Grid (.sdat, .sg-grd-z) | t SAR_CEOS | CEOS SAR Image | f SDTS | SDTS Raster | f SENTINEL2 | Sentinel 2 | f SGI | SGI Image File Format 1.0 | f SNODAS | Snow Data Assimilation System | f SRP | Standard Raster Product (ASRP/USRP) | f SRTMHGT | SRTMHGT File Format | t Terragen | Terragen heightfield | f TIL | EarthWatch .TIL | f TSX | TerraSAR-X Product | f USGSDEM | USGS Optional ASCII DEM (and CDED) | t VICAR | MIPL VICAR file | f VRT | Virtual Raster | t WCS | OGC Web Coverage Service | f WMS | OGC Web Map Service | t WMTS | OGC Web Map Tile Service | t XPM | X11 PixMap Format | t XYZ | ASCII Gridded XYZ | t ZMap | ZMap Plus Grid | t
List of options for each driver.
Output the create options XML column of JPEG as a table. These creator options can be used in the ST_AsGDALRaster options argument.
SELECT (xpath('@name', g.opt))[1]::text As oname,
(xpath('@type', g.opt))[1]::text As otype,
(xpath('@description', g.opt))[1]::text As descrip
FROM (SELECT unnest(xpath('/CreationOptionList/Option', create_options::xml)) As opt
FROM ST_GDALDrivers()
WHERE short_name = 'JPEG') As g;oname | otype | descrip
--------------------+---------+-------------------------------------------------
PROGRESSIVE | boolean | whether to generate a progressive JPEG
QUALITY | int | good=100, bad=0, default=75
WORLDFILE | boolean | whether to generate a worldfile
INTERNAL_MASK | boolean | whether to generate a validity mask
COMMENT | string | Comment
SOURCE_ICC_PROFILE | string | ICC profile encoded in Base64
EXIF_THUMBNAIL | boolean | whether to generate an EXIF thumbnail(overview).
By default its max dimension will be 128
THUMBNAIL_WIDTH | int | Forced thumbnail width
THUMBNAIL_HEIGHT | int | Forced thumbnail height
(9 rows)This example turns a few common GeoTIFF creator options into a compact table.
WITH gtiff_options AS (
SELECT
option_name,
option_type,
default_value
FROM ST_GDALDrivers() AS driver
CROSS JOIN LATERAL XMLTABLE(
'/CreationOptionList/Option'
PASSING (driver.create_options::xml)
COLUMNS
option_name text PATH '@name',
option_type text PATH '@type',
default_value text PATH '@default'
) AS options
WHERE driver.short_name = 'GTiff'
)
SELECT option_name AS name, option_type AS type, coalesce(default_value, '') AS default_value
FROM gtiff_options
WHERE option_name = ANY (ARRAY[
'COMPRESS',
'INTERLEAVE',
'TILED',
'BLOCKXSIZE',
'BLOCKYSIZE',
'JPEG_QUALITY'
])
ORDER BY 1;name | type | default_value ---------------+---------------+--------------- BLOCKXSIZE | int | BLOCKYSIZE | int | COMPRESS | string-select | INTERLEAVE | string-select | PIXEL JPEG_QUALITY | int | 75 TILED | boolean | (6 rows)
Use XMLTABLE to expose selected GTiff creation options as rows. The same pattern can be used without the name filter to inspect the full XML document.
SET postgis.gdal_enabled_drivers = 'ENABLE_ALL';
SELECT option_name, option_type
FROM ST_GDALDrivers() AS driver
CROSS JOIN LATERAL XMLTABLE(
'/CreationOptionList/Option'
PASSING (driver.create_options::xml)
COLUMNS
option_name text PATH '@name',
option_type text PATH '@type'
) AS options
WHERE driver.short_name = 'GTiff'
AND option_name IN ('COMPRESS', 'TILED', 'BIGTIFF')
ORDER BY option_name;option_name | option_type -------------+--------------- BIGTIFF | string-select COMPRESS | string-select TILED | boolean (3 rows)
UpdateRasterSRID — Ändra SRID för alla raster i den användarspecifika kolumnen och tabellen.
raster UpdateRasterSRID(name schema_name, name table_name, name column_name, integer new_srid);
raster UpdateRasterSRID(name table_name, name column_name, integer new_srid);
Ändra SRID för alla raster i den användarspecificerade kolumnen och tabellen. Funktionen släpper alla lämpliga kolumnbegränsningar (utsträckning, inriktning och SRID) innan SRID ändras för den angivna kolumnens raster.
![]() | |
Data (bandpixelvärden) i rastrerna berörs inte av denna funktion. Endast rastrets metadata ändras. |
Tillgänglighet: 2.1.0
ST_CreateOverview — Skapa en version med reducerad upplösning av en given rastertäckning.
regclass ST_CreateOverview(regclass tab, name col, int factor, text algo='NearestNeighbor');
Skapa en översiktstabell med omsamplade plattor från källtabellen. Utdatabrickorna kommer att ha samma storlek som indatabrickorna och täcka samma spatiala utsträckning med en lägre upplösning (pixelstorleken kommer att vara 1/faktor av originalet i båda riktningarna).
Översiktstabellen kommer att göras tillgänglig i katalogen raster_overviews och kommer att ha rasterbegränsningar.
Algoritmalternativen är: "NearestNeighbor", "Bilinear", "Cubic", "CubicSpline" och "Lanczos". Hänvisa till: GDAL Warp resampling methods för mer information.
Tillgänglighet: 2.2.0
Generellt bättre kvalitet på utdata, men långsammare till produktformat
SELECT ST_CreateOverview('mydata.mytable'::regclass, 'rast', 2, 'Lanczos');Utdata till snabbare för att bearbeta standard närmaste granne
SELECT ST_CreateOverview('mydata.mytable'::regclass, 'rast', 2);ST_AddBand — Returnerar ett raster med det eller de nya banden av given typ som lagts till med givet initialvärde på den givna indexplatsen. Om inget index anges läggs bandet till i slutet.
(1) raster ST_AddBand(raster rast, addbandarg[] addbandargset);
(2) raster ST_AddBand(raster rast, integer index, text pixeltype, double precision initialvalue=0, double precision nodataval=NULL);
(3) raster ST_AddBand(raster rast, text pixeltype, double precision initialvalue=0, double precision nodataval=NULL);
(4) raster ST_AddBand(raster torast, raster fromrast, integer fromband=1, integer torastindex=at_end);
(5) raster ST_AddBand(raster torast, raster[] fromrasts, integer fromband=1, integer torastindex=at_end);
(6) raster ST_AddBand(raster rast, integer index, text outdbfile, integer[] outdbindex, double precision nodataval=NULL);
(7) raster ST_AddBand(raster rast, text outdbfile, integer[] outdbindex, integer index=at_end, double precision nodataval=NULL);
Returnerar ett raster med ett nytt band tillagt i given position (index), av given typ, med givet initialt värde och med givet nodatavärde. Om inget index anges läggs bandet till i slutet. Om inget fromband anges antas band 1. Pixel type är en strängrepresentation av en av de pixeltyper som anges i ST_BandPixelType. Om ett befintligt index anges ökas alla efterföljande band >= det indexet med 1. Om ett startvärde som är större än pixeltypens max anges, sätts startvärdet till det högsta värde som pixeltypen tillåter.
För den variant som tar en array av addbandarg (Variant 1) är indexvärdet för ett specifikt addbandarg relativt till rastret vid den tidpunkt då det band som beskrivs av det addbandarg läggs till i rastret. Se exemplet Multiple New Bands nedan.
För den variant som tar en array av raster (variant 5), om torast är NULL, ackumuleras fromband-bandet för varje raster i arrayen till ett nytt raster.
För de varianter som tar utdbfile (variant 6 och 7) måste värdet innehålla den fullständiga sökvägen till rasterfilen. Filen måste också vara tillgänglig för postgres-serverprocessen.
Förbättrad: 2.1.0-stöd för addbandarg har lagts till.
Förbättrad: 2.1.0 stöd för nya out-db band tillagt.
Single New Band.
This example adds another 8-bit unsigned integer band with pixels initialized to 200.
UPDATE dummy_rast
SET rast = ST_AddBand(rast, '8BUI'::text, 200)
WHERE rid = 1;
Create an empty raster 100x100 units, with upper left right at 0, add 2 bands (band 1 is 0/1 boolean bit switch, band2 allows values 0-15) Uses addbandargs.
Output metadata for the raster bands to verify they are correct.
INSERT INTO dummy_rast(rid, rast)
VALUES(10, ST_AddBand(ST_MakeEmptyRaster(100, 100, 0, 0, 1, -1, 0, 0, 0),
ARRAY[
ROW(1, '1BB'::text, 0, NULL),
ROW(2, '4BUI'::text, 0, NULL)
]::addbandarg[]
)
);
SELECT (bmd).*
FROM (SELECT ST_BandMetaData(rast, generate_series(1, 2)) As bmd
FROM dummy_rast WHERE rid = 10) AS foo;pixeltype | nodatavalue | isoutdb | path -----------+----------------+-------------+---------+------ 1BB | | f | 4BUI | | f |
This example outputs metadata for the raster.
SELECT (rmd).width, (rmd).height, (rmd).numbands
FROM (SELECT ST_MetaData(rast) As rmd
FROM dummy_rast WHERE rid = 10) AS foo;width | height | numbands -------+--------+---------- 100 | 100 | 2
Multiple New Bands.
SELECT
*
FROM ST_BandMetaData(ST_AddBand(ST_MakeEmptyRaster(10, 10, 0, 0, 1, -1, 0, 0, 0),
ARRAY[
ROW(NULL, '8BUI', 255, 0),
ROW(NULL, '16BUI', 1, 2),
ROW(2, '32BUI', 100, 12),
ROW(2, '32BF', 3.14, -1)
]::addbandarg[]
),
ARRAY[]::integer[]
);bandnum | pixeltype | nodatavalue | isoutdb | path | outdbbandnum | filesize | filetimestamp
---------+-----------+-------------+---------+------+--------------+----------+---------------
1 | 8BUI | 0 | f | null | null | null | null
2 | 32BF | -1 | f | null | null | null | null
3 | 32BUI | 12 | f | null | null | null | null
4 | 16BUI | 2 | f | null | null | null | nullAggregate the 1st band of a table of like rasters into a single raster. With as many bands as there are test_types and as many rows (new rasters) as there are mice. Note that The ORDER BY test_type clause relies on aggregate ORDER BY support. The resulting raster will have a band for each test_type alphabetical by test_type. For mouse lovers: No mice were harmed in this exercise.
SELECT
mouse,
ST_AddBand(NULL, array_agg(rast ORDER BY test_type), 1) As rast
FROM mice_studies
GROUP BY mouse;
New Out-db band.
SELECT
*
FROM ST_BandMetaData(ST_AddBand(ST_MakeEmptyRaster(10, 10, 0, 0, 1, -1, 0, 0, 0),
'/home/raster/mytestraster.tif'::text, NULL::int[]
),
ARRAY[]::integer[]
);bandnum | pixeltype | nodatavalue | isoutdb | path
---------+-----------+-------------+---------+------
1 | 8BUI | | t | /home/raster/mytestraster.tif
2 | 8BUI | | t | /home/raster/mytestraster.tif
3 | 8BUI | | t | /home/raster/mytestraster.tifST_AsRaster — Konverterar en PostGIS-geometri till ett PostGIS-raster.
raster ST_AsRaster(geometry geom, raster ref, text pixeltype, double precision value=1, double precision nodataval=0, boolean touched=false);
raster ST_AsRaster(geometry geom, raster ref, text[] pixeltype=ARRAY['8BUI'], double precision[] value=ARRAY[1], double precision[] nodataval=ARRAY[0], boolean touched=false);
raster ST_AsRaster(geometry geom, double precision scalex, double precision scaley, double precision gridx, double precision gridy, text pixeltype, double precision value=1, double precision nodataval=0, double precision skewx=0, double precision skewy=0, boolean touched=false);
raster ST_AsRaster(geometry geom, double precision scalex, double precision scaley, double precision gridx=NULL, double precision gridy=NULL, text[] pixeltype=ARRAY['8BUI'], double precision[] value=ARRAY[1], double precision[] nodataval=ARRAY[0], double precision skewx=0, double precision skewy=0, boolean touched=false);
raster ST_AsRaster(geometry geom, double precision scalex, double precision scaley, text pixeltype, double precision value=1, double precision nodataval=0, double precision upperleftx=NULL, double precision upperlefty=NULL, double precision skewx=0, double precision skewy=0, boolean touched=false);
raster ST_AsRaster(geometry geom, double precision scalex, double precision scaley, text[] pixeltype, double precision[] value=ARRAY[1], double precision[] nodataval=ARRAY[0], double precision upperleftx=NULL, double precision upperlefty=NULL, double precision skewx=0, double precision skewy=0, boolean touched=false);
raster ST_AsRaster(geometry geom, integer width, integer height, double precision gridx, double precision gridy, text pixeltype, double precision value=1, double precision nodataval=0, double precision skewx=0, double precision skewy=0, boolean touched=false);
raster ST_AsRaster(geometry geom, integer width, integer height, double precision gridx=NULL, double precision gridy=NULL, text[] pixeltype=ARRAY['8BUI'], double precision[] value=ARRAY[1], double precision[] nodataval=ARRAY[0], double precision skewx=0, double precision skewy=0, boolean touched=false);
raster ST_AsRaster(geometry geom, integer width, integer height, text pixeltype, double precision value=1, double precision nodataval=0, double precision upperleftx=NULL, double precision upperlefty=NULL, double precision skewx=0, double precision skewy=0, boolean touched=false);
raster ST_AsRaster(geometry geom, integer width, integer height, text[] pixeltype, double precision[] value=ARRAY[1], double precision[] nodataval=ARRAY[0], double precision upperleftx=NULL, double precision upperlefty=NULL, double precision skewx=0, double precision skewy=0, boolean touched=false);
Konverterar en PostGIS-geometri till ett PostGIS-raster. De många varianterna erbjuder tre grupper av möjligheter att ställa in justering och pixelstorlek för det resulterande rastret.
Den första gruppen, som består av de två första varianterna, producerar ett raster med samma inriktning (scalex, scaley, gridx och gridy), pixeltyp och nodatavärde som det tillhandahållna referensrastret. Du skickar i allmänhet detta referensraster genom att koppla samman tabellen som innehåller geometrin med tabellen som innehåller referensrastret.
Den andra gruppen, som består av fyra varianter, låter dig ställa in rastrets dimensioner genom att ange parametrarna för en pixelstorlek(scalex & scaley och skewx & skewy). Bredden och höjden på det resulterande rastret kommer att justeras för att passa geometrins omfattning. I de flesta fall måste du kasta heltal scalex & scaley-argument till dubbel precision så att PostgreSQL väljer rätt variant.
Den tredje gruppen, som består av fyra varianter, låter dig fastställa rastrets dimensioner genom att ange rastrets dimensioner (width & height). Parametrarna för pixelstorleken (scalex & scaley och skewx & skewy) i det resulterande rastret kommer att justeras för att passa geometrins utsträckning.
De två första varianterna av var och en av de två sista grupperna låter dig ange inriktningen med ett godtyckligt hörn av inriktningsrutnätet (gridx & gridy) och de två sista varianterna tar det övre vänstra hörnet (upperleftx & upperlefty).
Varje variantgrupp gör det möjligt att producera ett enbandsraster eller ett flerbandsraster. För att producera ett raster med flera band måste du tillhandahålla en array med pixeltyper(pixeltype[]), en array med initiala värden (value) och en array mednodatavärden (nodataval). Om pixeltyped inte tillhandahålls är standardvärdet 8BUI, värdena 1 och nodataval 0.
Utdatarastret kommer att ha samma spatiala referens som källgeometrin. Det enda undantaget är för varianter med ett referensraster. I detta fall kommer det resulterande rastret att få samma SRID som referensrastret.
Den valfria parametern touched är som standard false och mappar till rasteriseringsalternativet GDAL ALL_TOUCHED, som avgör om pixlar som berörs av linjer eller polygoner ska brännas. Inte bara de som ligger på linjens renderbana eller vars mittpunkt ligger inom polygonen.
Detta är särskilt användbart för att rendera jpeg- och png-filer av geometrier direkt från databasen när de används i kombination med ST_AsPNG och andra funktioner i ST_AsGDALRaster -familjen.
Tillgänglighet: 2.0.0 - kräver GDAL >= 1.6.0.
Curved geometry inputs are linearized before rasterization, including NURBSCurve inputs handled by PostGIS. TIN and PolyhedralSurface inputs are not supported.
This example outputs a black circle on a white background, occupying 150 by 150 pixels.
SELECT ST_AsPNG(
ST_AsRaster(
ST_Buffer(ST_Point(1, 5), 10),
150, 150,
ARRAY['8BUI', '8BUI', '8BUI'],
ARRAY[0, 0, 0],
ARRAY[255, 255, 255]
)
) AS image;image
-------------------------------
PNG image, 150 x 150 pixels
This example maps bands to RGB channels, producing the teal value (118,154,118).
SELECT ST_AsPNG(
ST_AsRaster(
ST_Buffer('LINESTRING(50 50,150 150,150 50)'::geometry, 10, 'join=bevel'),
200, 200,
ARRAY['8BUI', '8BUI', '8BUI'],
ARRAY[118, 154, 118],
ARRAY[255, 255, 255]
)
) AS image;image
-------------------------------
PNG image, 200 x 200 pixels
ST_AsRasterAgg — Aggregera. Renderar PostGIS-geometrier till ett nytt raster.
raster ST_AsRasterAgg(geometry geom, double precision val, raster ref, text pixeltype, double precision nodataval, text uniontype, boolean touched);
Returnerar ett enbandsraster som innehåller den renderade versionen av alla inkommande geometrier, var och en med sitt associerade värde.
Tillgänglighet: 3.6.0
WITH inp(g, v) AS (
VALUES
( ST_Buffer(ST_MakePoint(10, 0), 10), 1 ),
( ST_Buffer(ST_MakePoint(20, 0), 10), 2 )
),
agg AS (
SELECT ST_AsRasterAgg(
g,
v,
ST_MakeEmptyRaster(0, 0, 0, 0, 1.0),
'8BUI',
99,
'SUM',
true
) r
FROM inp
)
SELECT
ST_Width(r) w,
ST_Height(r) h,
ST_Value(r, 'POINT(5 0)') v5_0,
ST_Value(r, 'POINT(15 0)') v15_0,
ST_Value(r, 'POINT(25 0)') v25_0
FROM agg;w | h | v5_0 | v15_0 | v25_0 ----+----+------+-------+------- 30 | 20 | 1 | 3 | 2 (1 row)
ST_Band — Returnerar ett eller flera band från ett befintligt raster som ett nytt raster. Användbart för att bygga nya raster från befintliga raster.
raster ST_Band(raster rast, integer[] nbands = ARRAY[1]);
raster ST_Band(raster rast, integer nband);
raster ST_Band(raster rast, text nbands, character delimiter=,);
Returnerar ett eller flera band i ett befintligt raster som ett nytt raster. Användbar för att bygga nya raster från befintliga raster eller exportera endast utvalda band i ett raster eller omorganisera ordningen på banden i ett raster. Om inget band anges eller om något av de angivna banden inte finns i rastret returneras alla band. Används som en hjälpfunktion i olika funktioner, t.ex. för att radera ett band.
![]() | |
För funktionen |
Tillgänglighet: 2.0.0
This example creates two rasters: one containing band 1 of dummy_rast, and one containing band 2 reclassified as 2BUI.
SELECT ST_NumBands(rast1) As numb1, ST_BandPixelType(rast1) As pix1,
ST_NumBands(rast2) As numb2, ST_BandPixelType(rast2) As pix2
FROM (
SELECT ST_Band(rast) As rast1, ST_Reclass(ST_Band(rast, 3), '100-200):1, [200-254:2', '2BUI') As rast2
FROM dummy_rast
WHERE rid = 2) As foo;numb1 | pix1 | numb2 | pix2
-------+------+-------+------
1 | 8BUI | 1 | 2BUIReturn bands 2 and 3 using array cast syntax.
SELECT ST_NumBands(ST_Band(rast, '{2,3}'::int[])) As num_bands
FROM dummy_rast WHERE rid=2;
2
Return bands 2 and 3 using array syntax.
SELECT ST_NumBands(ST_Band(rast, ARRAY[2, 3])) As num_bands
FROM dummy_rast
WHERE rid=2;
2
This example uses three distinct shapes as the red, green, and blue bands of a synthetic raster. It compares the original RGB raster with band 2 followed by band 1 twice, and with band 3 alone.
WITH canvas AS (
SELECT ST_AddBand(
ST_AddBand(
ST_AddBand(
ST_MakeEmptyRaster(128, 128, 0, 128, 1, -1, 0, 0, 0),
'8BUI'::text, 0::double precision, 0::double precision
),
'8BUI'::text, 0::double precision, 0::double precision
),
'8BUI'::text, 0::double precision, 0::double precision
) AS rast
), bands AS (
SELECT ST_SetValue(
ST_SetValue(
ST_SetValue(rast, 1, ST_Buffer('POINT(32 96)'::geometry, 22), 220),
2, ST_Buffer('LINESTRING(18 20,110 110)'::geometry, 6,
'endcap=flat join=bevel'), 210
),
3, ST_Buffer('LINESTRING(10 48,118 48)'::geometry, 7,
'endcap=flat'), 180
) AS rast
FROM canvas
)
SELECT ST_AsPNG(rast) AS "original RGB",
ST_AsPNG(ST_Band(rast, ARRAY[2, 1, 1])) AS "bands 2,1,1",
ST_AsPNG(ST_Band(rast, 3)) AS "band 3"
FROM bands;
original RGB | bands 2,1,1 | band 3 -----------------------------+----------------------------+---------------------------- PNG image, 128 x 128 pixels | PNG image, 128 x 128 pixels | PNG image, 128 x 128 pixels
Band selection from a multi-band raster.
![]() original (kolumn rast) | ![]() dupe_band |
![]() sing_band |
ST_MakeEmptyCoverage — Täck georefererat område med ett rutnät av tomma rasterplattor.
raster ST_MakeEmptyCoverage(integer tilewidth, integer tileheight, integer width, integer height, double precision upperleftx, double precision upperlefty, double precision scalex, double precision scaley, double precision skewx, double precision skewy, integer srid=unknown);
Skapa en uppsättning rasterplattor med ST_MakeEmptyRaster. Grid-dimensionen är bredd och höjd. Plattdimensionen är tilewidth och tileheight. Det täckta georefererade området är från övre vänstra hörnet(upperleftx, upperlefty) till nedre högra hörnet( upperleftx + bredd * scalex, upperlefty + höjd * scaley).
![]() | |
Observera att scaley i allmänhet är negativt för raster och scalex i allmänhet är positivt. Så det nedre högra hörnet kommer att ha ett lägre y-värde och ett högre x-värde än det övre vänstra hörnet. |
Tillgänglighet: 2.4.0
Skapa 16 plattor i ett 4x4 rutnät för att täcka WGS84-området från övre vänstra hörnet (22, 77) till nedre högra hörnet (55, 33).
SELECT (ST_MetaData(tile)).* FROM ST_MakeEmptyCoverage(1, 1, 4, 4, 22, 33, (55 - 22)/(4)::float, (33 - 77)/(4)::float, 0., 0., 4326) tile;
upperleftx | upperlefty | width | height | scalex | scaley | skewx | skewy | srid | numbands
-------------------------------------------------------------------------------------
22 | 33 | 1 | 1 | 8.25 | -11 | 0 | 0 | 4326 | 0
30.25 | 33 | 1 | 1 | 8.25 | -11 | 0 | 0 | 4326 | 0
38.5 | 33 | 1 | 1 | 8.25 | -11 | 0 | 0 | 4326 | 0
46.75 | 33 | 1 | 1 | 8.25 | -11 | 0 | 0 | 4326 | 0
22 | 22 | 1 | 1 | 8.25 | -11 | 0 | 0 | 4326 | 0
30.25 | 22 | 1 | 1 | 8.25 | -11 | 0 | 0 | 4326 | 0
38.5 | 22 | 1 | 1 | 8.25 | -11 | 0 | 0 | 4326 | 0
46.75 | 22 | 1 | 1 | 8.25 | -11 | 0 | 0 | 4326 | 0
22 | 11 | 1 | 1 | 8.25 | -11 | 0 | 0 | 4326 | 0
30.25 | 11 | 1 | 1 | 8.25 | -11 | 0 | 0 | 4326 | 0
38.5 | 11 | 1 | 1 | 8.25 | -11 | 0 | 0 | 4326 | 0
46.75 | 11 | 1 | 1 | 8.25 | -11 | 0 | 0 | 4326 | 0
22 | 0 | 1 | 1 | 8.25 | -11 | 0 | 0 | 4326 | 0
30.25 | 0 | 1 | 1 | 8.25 | -11 | 0 | 0 | 4326 | 0
38.5 | 0 | 1 | 1 | 8.25 | -11 | 0 | 0 | 4326 | 0
46.75 | 0 | 1 | 1 | 8.25 | -11 | 0 | 0 | 4326 | 0ST_MakeEmptyRaster — Returnerar ett tomt raster (utan band) med givna dimensioner (bredd & höjd), övre vänstra X och Y, pixelstorlek och rotation (scalex, scaley, skewx & skewy) och referenssystem (srid). Om ett raster skickas in returneras ett nytt raster med samma storlek, inriktning och SRID. Om srid utelämnas sätts den spatiala ref till okänd (0).
raster ST_MakeEmptyRaster(raster rast);
raster ST_MakeEmptyRaster(integer width, integer height, float8 upperleftx, float8 upperlefty, float8 scalex, float8 scaley, float8 skewx, float8 skewy, integer srid=unknown);
raster ST_MakeEmptyRaster(integer width, integer height, float8 upperleftx, float8 upperlefty, float8 pixelsize);
Returnerar ett tomt raster (utan band) med givna dimensioner (bredd & höjd) och georefererat i spatiala (eller världsliga) koordinater med övre vänstra X (upperleftx), övre vänstra Y (upperlefty), pixelstorlek och rotation (scalex, scaley, skewx & skewy) och referenssystem (srid).
Den senaste versionen använder en enda parameter för att ange pixelstorleken (pixelsize). scalex sätts till detta argument och scaley sätts till det negativa värdet av detta argument. skewx och skewy sätts till 0.
Om ett befintligt raster skickas in returneras ett nytt raster med samma inställningar för metadata (utan banden).
Om ingen srid anges är standardvärdet 0. När du har skapat ett tomt raster vill du förmodligen lägga till band i det och kanske redigera det. Se ST_AddBand för att definiera band och ST_SetValue för att ställa in initiala pixelvärden.
Use an existing raster as a template and output metadata of the rasters we added.
INSERT INTO dummy_rast(rid, rast)
VALUES(3, ST_MakeEmptyRaster(100, 100, 0.0005, 0.0005, 1, 1, 0, 0, 4326) );
INSERT INTO dummy_rast(rid, rast)
SELECT 4, ST_MakeEmptyRaster(rast)
FROM dummy_rast WHERE rid = 3;
SELECT
rid,
(md).width,
(md).height,
(md).scalex,
(md).scaley,
(md).srid
FROM (
SELECT rid, ST_MetaData(rast) AS md
FROM dummy_rast
WHERE rid IN (3, 4)
) AS foo
ORDER BY rid;
rid | width | height | scalex | scaley | srid -----+-------+--------+--------+--------+------ 3 | 100 | 100 | 1 | 1 | 4326 4 | 100 | 100 | 1 | 1 | 4326
ST_AddBand, ST_MetaData, ST_ScaleX, ST_ScaleY, ST_SetValue, ST_SkewX, , ST_SkewY
ST_Tile — Returnerar en uppsättning raster som är resultatet av uppdelningen av inmatningsrastret baserat på de önskade dimensionerna för utdatarastren.
setof raster ST_Tile(raster rast, int[] nband, integer width, integer height, boolean padwithnodata=FALSE, double precision nodataval=NULL);
setof raster ST_Tile(raster rast, integer nband, integer width, integer height, boolean padwithnodata=FALSE, double precision nodataval=NULL);
setof raster ST_Tile(raster rast, integer width, integer height, boolean padwithnodata=FALSE, double precision nodataval=NULL);
Returnerar en uppsättning raster som är resultatet av uppdelningen av inmatningsrastret baserat på de önskade dimensionerna för utdatarastren.
Om padwithnodata = FALSE kan kantplattor på rastrets högra och nedre sidor ha andra dimensioner än resten av plattorna. Om padwithnodata = TRUE har alla plattor samma dimensioner, men det är möjligt att kantplattor fylls på med NODATA-värden. Om rasterband inte har NODATA-värden angivna kan ett sådant anges genom att ställa in nodataval.
![]() | |
Om ett specificerat band i indatarastret är out-of-db, kommer motsvarande band i utdatarastren också att vara out-of-db. |
Tillgänglighet: 2.1.0
WITH foo AS (
SELECT ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(3, 3, 0, 0, 1, -1, 0, 0, 0), 1, '8BUI', 1, 0), 2, '8BUI', 10, 0) AS rast UNION ALL
SELECT ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(3, 3, 3, 0, 1, -1, 0, 0, 0), 1, '8BUI', 2, 0), 2, '8BUI', 20, 0) AS rast UNION ALL
SELECT ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(3, 3, 6, 0, 1, -1, 0, 0, 0), 1, '8BUI', 3, 0), 2, '8BUI', 30, 0) AS rast UNION ALL
SELECT ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(3, 3, 0, -3, 1, -1, 0, 0, 0), 1, '8BUI', 4, 0), 2, '8BUI', 40, 0) AS rast UNION ALL
SELECT ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(3, 3, 3, -3, 1, -1, 0, 0, 0), 1, '8BUI', 5, 0), 2, '8BUI', 50, 0) AS rast UNION ALL
SELECT ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(3, 3, 6, -3, 1, -1, 0, 0, 0), 1, '8BUI', 6, 0), 2, '8BUI', 60, 0) AS rast UNION ALL
SELECT ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(3, 3, 0, -6, 1, -1, 0, 0, 0), 1, '8BUI', 7, 0), 2, '8BUI', 70, 0) AS rast UNION ALL
SELECT ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(3, 3, 3, -6, 1, -1, 0, 0, 0), 1, '8BUI', 8, 0), 2, '8BUI', 80, 0) AS rast UNION ALL
SELECT ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(3, 3, 6, -6, 1, -1, 0, 0, 0), 1, '8BUI', 9, 0), 2, '8BUI', 90, 0) AS rast
), bar AS (
SELECT ST_Union(rast) AS rast FROM foo
), baz AS (
SELECT
row_number() OVER (
ORDER BY ST_UpperLeftY(rast) DESC, ST_UpperLeftX(rast)
) AS tile_id,
rast
FROM (
SELECT ST_Tile(rast, 3, 3, TRUE) AS rast
FROM bar
) AS tiled
)
SELECT
tile_id,
ST_UpperLeftX(rast) AS ulx,
ST_UpperLeftY(rast) AS uly,
ST_Value(rast, 1, 1, 1) AS band1,
ST_Value(rast, 2, 1, 1) AS band2
FROM baz;tile_id | ulx | uly | band1 | band2
---------+-----+-----+-------+-------
1 | 0 | 0 | 1 | 10
2 | 3 | 0 | 2 | 20
3 | 6 | 0 | 3 | 30
4 | 0 | -3 | 4 | 40
5 | 3 | -3 | 5 | 50
6 | 6 | -3 | 6 | 60
7 | 0 | -6 | 7 | 70
8 | 3 | -6 | 8 | 80
9 | 6 | -6 | 9 | 90
(9 rows)WITH foo AS (
SELECT ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(3, 3, 0, 0, 1, -1, 0, 0, 0), 1, '8BUI', 1, 0), 2, '8BUI', 10, 0) AS rast UNION ALL
SELECT ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(3, 3, 3, 0, 1, -1, 0, 0, 0), 1, '8BUI', 2, 0), 2, '8BUI', 20, 0) AS rast UNION ALL
SELECT ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(3, 3, 6, 0, 1, -1, 0, 0, 0), 1, '8BUI', 3, 0), 2, '8BUI', 30, 0) AS rast UNION ALL
SELECT ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(3, 3, 0, -3, 1, -1, 0, 0, 0), 1, '8BUI', 4, 0), 2, '8BUI', 40, 0) AS rast UNION ALL
SELECT ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(3, 3, 3, -3, 1, -1, 0, 0, 0), 1, '8BUI', 5, 0), 2, '8BUI', 50, 0) AS rast UNION ALL
SELECT ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(3, 3, 6, -3, 1, -1, 0, 0, 0), 1, '8BUI', 6, 0), 2, '8BUI', 60, 0) AS rast UNION ALL
SELECT ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(3, 3, 0, -6, 1, -1, 0, 0, 0), 1, '8BUI', 7, 0), 2, '8BUI', 70, 0) AS rast UNION ALL
SELECT ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(3, 3, 3, -6, 1, -1, 0, 0, 0), 1, '8BUI', 8, 0), 2, '8BUI', 80, 0) AS rast UNION ALL
SELECT ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(3, 3, 6, -6, 1, -1, 0, 0, 0), 1, '8BUI', 9, 0), 2, '8BUI', 90, 0) AS rast
), bar AS (
SELECT ST_Union(rast) AS rast FROM foo
), baz AS (
SELECT
row_number() OVER (
ORDER BY ST_UpperLeftY(rast) DESC, ST_UpperLeftX(rast)
) AS tile_id,
rast
FROM (
SELECT ST_Tile(rast, ARRAY[2], 3, 3) AS rast
FROM bar
) AS tiled
)
SELECT
tile_id,
ST_UpperLeftX(rast) AS ulx,
ST_UpperLeftY(rast) AS uly,
ST_Value(rast, 1, 1, 1) AS band_value
FROM baz;tile_id | ulx | uly | band_value
---------+-----+-----+------------
1 | 0 | 0 | 10
2 | 3 | 0 | 20
3 | 6 | 0 | 30
4 | 0 | -3 | 40
5 | 3 | -3 | 50
6 | 6 | -3 | 60
7 | 0 | -6 | 70
8 | 3 | -6 | 80
9 | 6 | -6 | 90
(9 rows)ST_Retile — Returnerar en uppsättning konfigurerade plattor från en godtyckligt uppdelad rastertäckning.
SETOF raster ST_Retile(regclass tab, name col, geometry ext, float8 sfx, float8 sfy, int tw, int th, text algo='NearestNeighbor');
Returnerar en uppsättning plattor med angiven skala (sfx, sfy) och maxstorlek (tw, th) och som täcker den angivna utsträckningen (ext) med data som kommer från den angivna rastertäckningen (tab, col).
Algoritmalternativen är: "NearestNeighbor", "Bilinear", "Cubic", "CubicSpline" och "Lanczos". Hänvisa till: GDAL Warp resampling methods för mer information.
Tillgänglighet: 2.2.0
ST_FromGDALRaster — Returnerar ett raster från en GDAL-rasterfil som stöds.
raster ST_FromGDALRaster(bytea gdaldata, integer srid=NULL);
Returnerar ett raster från en GDAL-rasterfil som stöds. gdaldata är av typen bytea och bör vara innehållet i GDAL-rasterfilen.
Om srid är NULL försöker funktionen automatiskt tilldela SRID från GDAL-rastret. Om srid anges kommer det angivna värdet att åsidosätta eventuellt automatiskt tilldelad SRID.
Tillgänglighet: 2.1.0
WITH foo AS (
SELECT ST_AsPNG(ST_AddBand(ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(2, 2, 0, 0, 0.1, -0.1, 0, 0, 4326), 1, '8BUI', 1, 0), 2, '8BUI', 2, 0), 3, '8BUI', 3, 0)) AS png
),
bar AS (
SELECT 1 AS rid, ST_FromGDALRaster(png) AS rast FROM foo
UNION ALL
SELECT 2 AS rid, ST_FromGDALRaster(png, 3310) AS rast FROM foo
)
SELECT
rid,
ST_MetaData(rast) AS metadata,
ST_SummaryStats(rast, 1) AS stats1,
ST_SummaryStats(rast, 2) AS stats2,
ST_SummaryStats(rast, 3) AS stats3
FROM bar
ORDER BY rid;rid | metadata | stats1 | stats2 | stats3 -----+---------------------------+---------------+---------------+---------------- 1 | (0,0,2,2,1,-1,0,0,0,3) | (4,4,1,0,1,1) | (4,8,2,0,2,2) | (4,12,3,0,3,3) 2 | (0,0,2,2,1,-1,0,0,3310,3) | (4,4,1,0,1,1) | (4,8,2,0,2,2) | (4,12,3,0,3,3) (2 rows)
ST_GeoReference — Returnerar metadata för georeferenser i GDAL- eller ESRI-format, vilket är vanligt förekommande i en world-fil. Standard är GDAL.
text ST_GeoReference(raster rast, text format=GDAL);
Returnerar metadata för georeferensen inklusive vagnsretur i GDAL- eller ESRI-format, vilket är vanligt förekommande i en world-fil. Standard är GDAL om ingen typ anges. typ är strängen 'GDAL' eller 'ESRI'.
Skillnaden mellan formatrepresentationer är följande:
GDAL:
scalex skewy skewx scaley upperleftx upperlefty
ESRI:
scalex skewy skewx scaley upperleftx + scalex*0.5 upperlefty + scaley*0.5
SELECT
format,
replace(ST_GeoReference(rast, format), E'\n', ' | ') AS georef
FROM dummy_rast
CROSS JOIN (VALUES ('ESRI'), ('GDAL')) AS formats(format)
WHERE rid = 1;format | georef --------+--------------------------------------------------------------------------- ESRI | 2.0000000000 | 0.0000000000 | 0.0000000000 | 3.0000000000 | 1.5000000000 | 2.0000000000 GDAL | 2.0000000000 | 0.0000000000 | 0.0000000000 | 3.0000000000 | 0.5000000000 | 0.5000000000 (2 rows)
ST_Height — Returnerar höjden på rastret i pixlar.
integer ST_Height(raster rast);
Returnerar höjden på rastret.
SELECT rid, ST_Height(rast) As rastheight FROM dummy_rast;
rid | rastheight -----+------------ 1 | 20 2 | 5
ST_IsEmpty — Returnerar true om rastret är tomt (bredd = 0 och höjd = 0). I annat fall returneras false.
boolean ST_IsEmpty(raster rast);
Returnerar true om rastret är tomt (bredd = 0 och höjd = 0). I annat fall returneras false.
Tillgänglighet: 2.0.0
SELECT ST_IsEmpty(ST_MakeEmptyRaster(100, 100, 0, 0, 0, 0, 0, 0))
f
SELECT ST_IsEmpty(ST_MakeEmptyRaster(0, 0, 0, 0, 0, 0, 0, 0))
t
ST_MemSize — Returnerar den mängd utrymme (i byte) som rastret tar upp.
integer ST_MemSize(raster rast);
Returnerar den mängd utrymme (i byte) som rastret tar upp.
Detta är ett trevligt komplement till PostgreSQL inbyggda funktioner pg_column_size, pg_size_pretty, pg_relation_size, pg_total_relation_size.
![]() | |
pg_relation_size som ger bytestorleken för en tabell kan returnera en bytestorlek som är lägre än ST_MemSize. Detta beror på att pg_relation_size inte lägger till toasted-tabellbidrag och stora geometrier lagras i TOAST-tabeller. pg_column_size kan returnera lägre eftersom den returnerar den komprimerade storleken. pg_total_relation_size - inkluderar tabellen, de toastade tabellerna och indexen. |
Tillgänglighet: 2.2.0
SELECT ST_MemSize(ST_AsRaster(ST_Buffer(ST_Point(1, 5), 10, 1000), 150, 150, '8BUI')) AS rast_mem;
22568
ST_MetaData — Returnerar grundläggande metadata om ett rasterobjekt, t.ex. pixelstorlek, rotation (skew), övre, nedre vänster etc.
record ST_MetaData(raster rast);
Returnerar grundläggande metadata om ett rasterobjekt, t.ex. pixelstorlek, rotation (skew), övre och nedre vänster etc. Kolumner som returneras: upperleftx | upperlefty | bredd | höjd | scalex | scaley | skewx | skewy | srid | numbands
SELECT
rid,
format('(%s, %s)', (md).upperleftx, (md).upperlefty) AS upper_left,
format('%sx%s', (md).width, (md).height) AS size,
format('(%s, %s)', (md).scalex, (md).scaley) AS scale,
format('(%s, %s)', (md).skewx, (md).skewy) AS skew,
(md).srid AS srid,
(md).numbands AS numbands
FROM (
SELECT rid, ST_MetaData(rast) AS md
FROM dummy_rast
) AS foo
ORDER BY rid;rid | upper_left | size | scale | skew | srid | numbands -----+--------------------------+-------+-----------------+--------+------+---------- 1 | (0.5, 0.5) | 10x20 | (2, 3) | (0, 0) | 0 | 0 2 | (3427927.75, 5793244) | 5x5 | (0.05, -0.05) | (0, 0) | 0 | 3 (2 rows)
ST_NumBands — Returnerar antalet band i rasterobjektet.
integer ST_NumBands(raster rast);
Returnerar antalet band i rasterobjektet.
SELECT rid, ST_NumBands(rast) As numbands FROM dummy_rast;
rid | numbands ----+---------- 1 | 0 2 | 3
ST_PixelHeight — Returnerar pixelhöjden i geometriska enheter i det spatiala referenssystemet.
double precision ST_PixelHeight(raster rast);
Returnerar höjden på en pixel i geometriska enheter i det spatiala referenssystemet. I det vanliga fallet där det inte finns någon skevhet är pixelhöjden bara skalförhållandet mellan geometriska koordinater och rasterpixlar.
Se ST_PixelWidth för en schematisk visualisering av förhållandet.
Rasters with no skew.
SELECT ST_Height(rast) As rastheight, ST_PixelHeight(rast) As pixheight,
ST_ScaleX(rast) As scalex, ST_ScaleY(rast) As scaley, ST_SkewX(rast) As skewx,
ST_SkewY(rast) As skewy
FROM dummy_rast;rastheight | pixheight | scalex | scaley | skewx | skewy
------------+-----------+--------+--------+-------+----------
20 | 3 | 2 | 3 | 0 | 0
5 | 0.05 | 0.05 | -0.05 | 0 | 0Rasters with skew different than 0.
SELECT ST_Height(rast) As rastheight, ST_PixelHeight(rast) As pixheight,
ST_ScaleX(rast) As scalex, ST_ScaleY(rast) As scaley, ST_SkewX(rast) As skewx,
ST_SkewY(rast) As skewy
FROM (SELECT ST_SetSkew(rast, 0.5, 0.5) As rast
FROM dummy_rast) As skewed;rastheight | pixheight | scalex | scaley | skewx | skewy
-----------+-------------------+--------+--------+-------+----------
20 | 3.04138126514911 | 2 | 3 | 0.5 | 0.5
5 | 0.502493781056044 | 0.05 | -0.05 | 0.5 | 0.5ST_PixelWidth — Returnerar pixelbredden i geometriska enheter i det spatiala referenssystemet.
double precision ST_PixelWidth(raster rast);
Returnerar bredden på en pixel i geometriska enheter i det spatiala referenssystemet. I det vanliga fallet där det inte finns någon skevhet är pixelbredden bara skalförhållandet mellan geometriska koordinater och rasterpixlar.
The following executable example draws the two pixel basis vectors on the same coordinate frame as a skewed raster footprint. The i direction vector is (scaleX, skewY); the j direction vector is (skewX, scaleY).
Pixel basis vectors and footprint for a raster with non-zero skew.
WITH raster AS (
SELECT ST_MakeEmptyRaster(
3, 3, 0, 0,
2, -3, 1, 0.5,
0
) AS rast
)
SELECT
ST_ConvexHull(rast) AS footprint,
ST_MakeLine(
ST_Point(0, 0),
ST_Point(ST_ScaleX(rast), ST_SkewY(rast))
) AS "i direction (scaleX, skewY)",
ST_MakeLine(
ST_Point(0, 0),
ST_Point(ST_SkewX(rast), ST_ScaleY(rast))
) AS "j direction (skewX, scaleY)"
FROM raster;POLYGON((0 0,6 1.5,9 -7.5,3 -9,0 0)) | LINESTRING(0 0,2 0.5) | LINESTRING(0 0,1 -3)
Rasters with no skew.
SELECT ST_Width(rast) As rastwidth, ST_PixelWidth(rast) As pixwidth, ST_ScaleX(rast) As scalex, ST_ScaleY(rast) As scaley, ST_SkewX(rast) As skewx, ST_SkewY(rast) As skewy FROM dummy_rast;
rastwidth | pixwidth | scalex | scaley | skewx | skewy -----------+----------+--------+--------+-------+---------- 10 | 2 | 2 | 3 | 0 | 0 5 | 0.05 | 0.05 | -0.05 | 0 | 0
Rasters with skew different than 0.
SELECT ST_Width(rast) As rastwidth, ST_PixelWidth(rast) As pixwidth, ST_ScaleX(rast) As scalex, ST_ScaleY(rast) As scaley, ST_SkewX(rast) As skewx, ST_SkewY(rast) As skewy FROM (SELECT ST_SetSkew(rast, 0.5, 0.5) As rast FROM dummy_rast) As skewed;
rastwidth | pixwidth | scalex | scaley | skewx | skewy -----------+-------------------+--------+--------+-------+---------- 10 | 2.06155281280883 | 2 | 3 | 0.5 | 0.5 5 | 0.502493781056044 | 0.05 | -0.05 | 0.5 | 0.5
ST_ScaleX — Returnerar X-komponenten av pixelbredden i enheter av koordinatreferenssystemet.
float8 ST_ScaleX(raster rast);
Returnerar X-komponenten av pixelbredden i enheter av koordinatreferenssystemet. Se World File för mer information.
Ändrad: 2.0.0. I WKTRaster-versioner kallades detta ST_PixelSizeX.
SELECT rid, ST_ScaleX(rast) As rastpixwidth FROM dummy_rast;
rid | rastpixwidth -----+-------------- 1 | 2 2 | 0.05
ST_ScaleY — Returnerar Y-komponenten av pixelhöjden i enheter av koordinatreferenssystemet.
float8 ST_ScaleY(raster rast);
Returnerar Y-komponenten av pixelhöjden i enheter av koordinatreferenssystemet. Kan vara negativ. Se World File för mer information.
Ändrad: 2.0.0. I WKTRaster-versioner kallades detta ST_PixelSizeY.
SELECT rid, ST_ScaleY(rast) As rastpixheight FROM dummy_rast;
rid | rastpixheight -----+--------------- 1 | 3 2 | -0.05
ST_RasterToWorldCoord — Returnerar rastrets övre vänstra hörn som geometriska X och Y (longitud och latitud) givet en kolumn och rad. Kolumn och rad börjar på 1.
record ST_RasterToWorldCoord(raster rast, integer xcolumn, integer yrow);
Returnerar det övre vänstra hörnet som geometriska X och Y (longitud och latitud) givet en kolumn och rad. X och Y som returneras är i geometriska enheter för det georefererade rastret. Numreringen av kolumn och rad börjar på 1, men om någon av parametrarna är noll, ett negativt tal eller ett tal som är större än respektive dimension av rastret, kommer den att returnera koordinater utanför rastret förutsatt att rastrets rutnät är tillämpligt utanför rastrets gränser.
Tillgänglighet: 2.1.0
This example uses a non-skewed raster.
SELECT
rid,
(ST_RasterToWorldCoord(rast, 1, 1)).*,
(ST_RasterToWorldCoord(rast, 2, 2)).*
FROM dummy_rastrid | longitude | latitude | longitude | latitude -----+------------+----------+-----------+------------ 1 | 0.5 | 0.5 | 2.5 | 3.5 2 | 3427927.75 | 5793244 | 3427927.8 | 5793243.95
This example uses a skewed raster.
SELECT
rid,
(ST_RasterToWorldCoord(rast, 1, 1)).*,
(ST_RasterToWorldCoord(rast, 2, 3)).*
FROM (
SELECT
rid,
ST_SetSkew(rast, 100.5, 0) As rast
FROM dummy_rast
) As foorid | longitude | latitude | longitude | latitude -----+------------+----------+-----------+----------- 1 | 0.5 | 0.5 | 203.5 | 6.5 2 | 3427927.75 | 5793244 | 3428128.8 | 5793243.9
ST_RasterToWorldCoordX — Returnerar den geometriska X-koordinaten uppe till vänster i ett raster, en kolumn och en rad. Numreringen av kolumner och rader börjar på 1.
float8 ST_RasterToWorldCoordX(raster rast, integer xcolumn);
float8 ST_RasterToWorldCoordX(raster rast, integer xcolumn, integer yrow);
Returnerar den övre vänstra X-koordinaten för en rasterkolumnrad i geometriska enheter för det georefererade rastret. Numreringen av kolumner och rader börjar på 1, men om du anger ett negativt tal eller ett tal som är högre än antalet kolumner i rastret, får du koordinater utanför rasterfilen till vänster eller höger med antagandet att skevheten och pixelstorlekarna är desamma som i det valda rastret.
![]() | |
För raster utan skevhet räcker det med att ange X-kolumnen. För skeva raster är den georefererade koordinaten en funktion av ST_ScaleX och ST_SkewX samt rad och kolumn. Ett felmeddelande visas om du bara anger X-kolumnen för ett snedställt raster. |
Ändrad: 2.1.0 I tidigare versioner kallades detta ST_Raster2WorldCoordX
This example shows that providing a column is sufficient for a non-skewed raster.
SELECT rid, ST_RasterToWorldCoordX(rast, 1) As x1coord,
ST_RasterToWorldCoordX(rast, 2) As x2coord,
ST_ScaleX(rast) As pixelx
FROM dummy_rast;rid | x1coord | x2coord | pixelx -----+------------+-----------+-------- 1 | 0.5 | 2.5 | 2 2 | 3427927.75 | 3427927.8 | 0.05
For fun let's skew it.
SELECT rid, ST_RasterToWorldCoordX(rast, 1, 1) As x1coord,
ST_RasterToWorldCoordX(rast, 2, 3) As x2coord,
ST_ScaleX(rast) As pixelx
FROM (SELECT rid, ST_SetSkew(rast, 100.5, 0) As rast FROM dummy_rast) As foo;rid | x1coord | x2coord | pixelx -----+------------+-----------+-------- 1 | 0.5 | 203.5 | 2 2 | 3427927.75 | 3428128.8 | 0.05
ST_RasterToWorldCoordY — Returnerar den geometriska Y-koordinaten i övre vänstra hörnet av ett raster, en kolumn och en rad. Numreringen av kolumner och rader börjar på 1.
float8 ST_RasterToWorldCoordY(raster rast, integer yrow);
float8 ST_RasterToWorldCoordY(raster rast, integer xcolumn, integer yrow);
Returnerar den övre vänstra Y-koordinaten för en rasterkolumnrad i geometriska enheter för det georefererade rastret. Numreringen av kolumner och rader börjar på 1, men om du anger ett negativt tal eller ett tal som är högre än antalet kolumner/rader i rastret, får du koordinater utanför rasterfilen till vänster eller höger med antagandet att skevheten och pixelstorlekarna är desamma som för den valda rasterplattan.
![]() | |
För raster som inte är snedställda räcker det att ange Y-kolumnen. För skeva raster är den georefererade koordinaten en funktion av ST_ScaleY och ST_SkewY samt rad och kolumn. Ett felmeddelande visas om du bara anger Y-raden för ett snedställt raster. |
Ändrad: 2.1.0 I tidigare versioner kallades detta ST_Raster2WorldCoordY
Non-skewed raster providing row is sufficient.
SELECT rid, ST_RasterToWorldCoordY(rast, 1) As y1coord,
ST_RasterToWorldCoordY(rast, 3) As y2coord,
ST_ScaleY(rast) As pixely
FROM dummy_rast;rid | y1coord | y2coord | pixely -----+---------+-----------+-------- 1 | 0.5 | 6.5 | 3 2 | 5793244 | 5793243.9 | -0.05
For fun let's skew it.
SELECT rid, ST_RasterToWorldCoordY(rast, 1, 1) As y1coord,
ST_RasterToWorldCoordY(rast, 2, 3) As y2coord,
ST_ScaleY(rast) As pixely
FROM (SELECT rid, ST_SetSkew(rast, 0, 100.5) As rast FROM dummy_rast) As foo;rid | y1coord | y2coord | pixely -----+---------+-----------+-------- 1 | 0.5 | 107 | 3 2 | 5793244 | 5793344.4 | -0.05
ST_Rotation — Returnerar rastrets rotation i radianer.
float8 ST_Rotation(raster rast);
Returnerar rastrets enhetliga rotation i radianer. Om ett raster inte har enhetlig rotation returneras NaN. Se World File för mer information.
SELECT rid, ST_Rotation(ST_SetScale(ST_SetSkew(rast, sqrt(2)), sqrt(2))) AS rot FROM dummy_rast;
rid | rot -----+------------------- 1 | 0.785398163397448 2 | 0.785398163397448
ST_SkewX — Returnerar georeferensens X skew (eller rotationsparameter).
float8 ST_SkewX(raster rast);
Returnerar georeferensens X-skevhet (eller rotationsparameter). Se World File för mer information.
WITH refs AS (
SELECT
rid,
format('(%s, %s)', ST_SkewX(rast), ST_SkewY(rast)) AS skew,
string_to_array(ST_GeoReference(rast), E'\n') AS georef
FROM dummy_rast
)
SELECT
rid,
skew,
term,
georef[idx] AS value
FROM refs
CROSS JOIN (VALUES
(1, 'scaleX'),
(2, 'skewY'),
(3, 'skewX'),
(4, 'scaleY'),
(5, 'originX'),
(6, 'originY')
) AS parts(idx, term)
ORDER BY rid, idx;rid | skew | term | value -----+--------+---------+-------------------- 1 | (0, 0) | scaleX | 2.0000000000 1 | (0, 0) | skewY | 0.0000000000 1 | (0, 0) | skewX | 0.0000000000 1 | (0, 0) | scaleY | 3.0000000000 1 | (0, 0) | originX | 0.5000000000 1 | (0, 0) | originY | 0.5000000000 2 | (0, 0) | scaleX | 0.0500000000 2 | (0, 0) | skewY | 0.0000000000 2 | (0, 0) | skewX | 0.0000000000 2 | (0, 0) | scaleY | -0.0500000000 2 | (0, 0) | originX | 3427927.7500000000 2 | (0, 0) | originY | 5793244.0000000000 (12 rows)
ST_SkewY — Returnerar georeferensens Y skew (eller rotationsparameter).
float8 ST_SkewY(raster rast);
Returnerar georeferensens Y-skevhet (eller rotationsparameter). Se World File för mer information.
WITH refs AS (
SELECT
rid,
format('(%s, %s)', ST_SkewX(rast), ST_SkewY(rast)) AS skew,
string_to_array(ST_GeoReference(rast), E'\n') AS georef
FROM dummy_rast
)
SELECT
rid,
skew,
term,
georef[idx] AS value
FROM refs
CROSS JOIN (VALUES
(1, 'scaleX'),
(2, 'skewY'),
(3, 'skewX'),
(4, 'scaleY'),
(5, 'originX'),
(6, 'originY')
) AS parts(idx, term)
ORDER BY rid, idx;rid | skew | term | value -----+--------+---------+-------------------- 1 | (0, 0) | scaleX | 2.0000000000 1 | (0, 0) | skewY | 0.0000000000 1 | (0, 0) | skewX | 0.0000000000 1 | (0, 0) | scaleY | 3.0000000000 1 | (0, 0) | originX | 0.5000000000 1 | (0, 0) | originY | 0.5000000000 2 | (0, 0) | scaleX | 0.0500000000 2 | (0, 0) | skewY | 0.0000000000 2 | (0, 0) | skewX | 0.0000000000 2 | (0, 0) | scaleY | -0.0500000000 2 | (0, 0) | originX | 3427927.7500000000 2 | (0, 0) | originY | 5793244.0000000000 (12 rows)
ST_SRID — Returnerar den spatiala referensidentifieraren för rastret enligt definitionen i tabellen spatial_ref_sys.
integer ST_SRID(raster rast);
Returnerar den spatiala referensidentifieraren för rasterobjektet enligt definitionen i tabellen spatial_ref_sys.
![]() | |
Non-georeferenced rasters and geometries use SRID 0. |
SELECT ST_SRID(rast) As srid FROM dummy_rast WHERE rid=1;
0
ST_Summary — Returnerar en textsammanfattning av innehållet i rastret.
text ST_Summary(raster rast);
Returnerar en textsammanfattning av innehållet i rastret.
Tillgänglighet: 2.1.0
SELECT ST_Summary(ST_AddBand(ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(10, 10, 0, 0, 1, -1, 0, 0, 0),
1, '8BUI', 1, 0
),
2, '32BF', 0, -9999
),
3, '16BSI', 0, NULL
)
);Raster of 10x10 pixels has 3 bands and extent of BOX(0 -10,10 0)+
band 1 of pixtype 8BUI is in-db with NODATA value of 0 +
band 2 of pixtype 32BF is in-db with NODATA value of -9999 +
band 3 of pixtype 16BSI is in-db with no NODATA value
(1 row)ST_UpperLeftX — Returnerar den övre vänstra X-koordinaten för rastret i projicerad spatial ref.
float8 ST_UpperLeftX(raster rast);
Returnerar den övre vänstra X-koordinaten för rastret i projicerad spatial ref.
SELECt rid, ST_UpperLeftX(rast) As ulx FROM dummy_rast;
rid | ulx -----+------------ 1 | 0.5 2 | 3427927.75
ST_UpperLeftY — Returnerar den övre vänstra Y-koordinaten för rastret i projicerad spatial ref.
float8 ST_UpperLeftY(raster rast);
Returnerar den övre vänstra Y-koordinaten för rastret i projicerad spatial ref.
SELECT rid, ST_UpperLeftY(rast) As uly FROM dummy_rast;
rid | uly -----+--------- 1 | 0.5 2 | 5793244
ST_Width — Returnerar rastrets bredd i pixlar.
integer ST_Width(raster rast);
Returnerar rastrets bredd i pixlar.
SELECT ST_Width(rast) As rastwidth FROM dummy_rast WHERE rid=1;
10
ST_WorldToRasterCoord — Returnerar det övre vänstra hörnet som kolumn och rad givet geometriskt X och Y (longitud och latitud) eller en punktgeometri uttryckt i rastrets spatiala referenskoordinatsystem.
record ST_WorldToRasterCoord(raster rast, geometry pt);
record ST_WorldToRasterCoord(raster rast, double precision longitude, double precision latitude);
Returnerar det övre vänstra hörnet som kolumn och rad givet geometriskt X och Y (longitud och latitud) eller en punktgeometri. Denna funktion fungerar oavsett om de geometriska X och Y eller punktgeometrin ligger utanför rastrets utsträckning eller inte. Geometriska X och Y måste uttryckas i rastrets spatiala referenskoordinatsystem.
Tillgänglighet: 2.1.0
SELECT
rid,
(ST_WorldToRasterCoord(rast, 3427927.8, 20.5)).*,
(ST_WorldToRasterCoord(rast, ST_GeomFromText('POINT(3427927.8 20.5)', ST_SRID(rast)))).*
FROM dummy_rast;rid | columnx | rowy | columnx | rowy -----+---------+-----------+---------+----------- 1 | 1713964 | 7 | 1713964 | 7 2 | 2 | 115864471 | 2 | 115864471
ST_WorldToRasterCoordX — Returnerar kolumnen i rastret för punktgeometrin (pt) eller en X- och Y-världskoordinat (xw, yw) som representeras i rastrets världsspatiala referenssystem.
integer ST_WorldToRasterCoordX(raster rast, geometry pt);
integer ST_WorldToRasterCoordX(raster rast, double precision xw);
integer ST_WorldToRasterCoordX(raster rast, double precision xw, double precision yw);
Returnerar kolumnen i rastret med punktgeometrin (pt) eller en X- och Y-världskoordinat (xw, yw). En punkt, eller (både xw- och yw-världskoordinater krävs om ett raster är skevt). Om ett raster inte är skevt räcker det med xw. Världskoordinaterna är i rastrets spatiala referenskoordinatsystem.
Ändrad: 2.1.0 I tidigare versioner kallades detta ST_World2RasterCoordX
SELECT rid, ST_WorldToRasterCoordX(rast, 3427927.8) As xcoord,
ST_WorldToRasterCoordX(rast, 3427927.8, 20.5) As xcoord_xwyw,
ST_WorldToRasterCoordX(rast, ST_GeomFromText('POINT(3427927.8 20.5)', ST_SRID(rast))) As ptxcoord
FROM dummy_rast;rid | xcoord | xcoord_xwyw | ptxcoord -----+---------+---------+---------- 1 | 1713964 | 1713964 | 1713964 2 | 1 | 1 | 1
ST_WorldToRasterCoordY — Returnerar raden i rastret för punktgeometrin (pt) eller en X- och Y-världskoordinat (xw, yw) som representeras i rastrets världsspatiala referenssystem.
integer ST_WorldToRasterCoordY(raster rast, geometry pt);
integer ST_WorldToRasterCoordY(raster rast, double precision xw);
integer ST_WorldToRasterCoordY(raster rast, double precision xw, double precision yw);
Returnerar raden i rastret för punktgeometrin (pt) eller en X- och Y-världskoordinat (xw, yw). En punkt, eller (både xw- och yw-världskoordinater krävs om ett raster är skevt). Om ett raster inte är skevt räcker det med xw. Världskoordinaterna är i rastrets spatiala referenskoordinatsystem.
Ändrad: 2.1.0 I tidigare versioner kallades detta ST_World2RasterCoordY
SELECT rid, ST_WorldToRasterCoordY(rast, 20.5) As ycoord,
ST_WorldToRasterCoordY(rast, 3427927.8, 20.5) As ycoord_xwyw,
ST_WorldToRasterCoordY(rast, ST_GeomFromText('POINT(3427927.8 20.5)', ST_SRID(rast))) As ptycoord
FROM dummy_rast;rid | ycoord | ycoord_xwyw | ptycoord -----+-----------+-------------+----------- 1 | 7 | 7 | 7 2 | 115864471 | 115864471 | 115864471
ST_BandMetaData — Returnerar grundläggande metadata för ett specifikt rasterband. bandnummer 1 antas om det inte specificeras.
(1) record ST_BandMetaData(raster rast, integer band=1);
(2) record ST_BandMetaData(raster rast, integer[] band);
Returnerar grundläggande metadata om ett rasterband. Kolumner som returneras: pixeltyp, nodatavärde, isoutdb, sökväg, outdbbandnummer, filstorlek, filstämpel.
![]() | |
Om rastret inte innehåller några band utlöses ett felmeddelande. |
![]() | |
Om bandet inte har något NODATA-värde är nodatavärdet NULL. |
![]() | |
Om isoutdb är False är sökväg, outdbbandnum, filstorlek och filetimestamp NULL. Om outdb-åtkomst är inaktiverad kommer även filesize och filetimestamp att vara NULL. |
Förbättrad: 2.5.0 för att inkludera outdbbandnum, filstorlek och filetimestamp för outdb-raster.
Variant 1.
SELECT
rid,
(foo.md).*
FROM (
SELECT
rid,
ST_BandMetaData(rast, 1) AS md
FROM dummy_rast
WHERE rid=2
) As foo;rid | pixeltype | nodatavalue | isoutdb | path | outdbbandnum
-----+-----------+-------------+---------+------+--------------
2 | 8BUI | 0 | f | |
(1 row)
Variant 2.
WITH foo AS (
SELECT
ST_AddBand(NULL::raster, '/home/pele/devel/geo/postgis-git/raster/test/regress/loader/Projected.tif', NULL::int[]) AS rast
)
SELECT
bandnum,
pixeltype,
isoutdb,
regexp_replace(path, '^.*/', '') AS file,
outdbbandnum
FROM ST_BandMetaData((SELECT rast FROM foo),
ARRAY[1, 3, 2]::int[]
);bandnum | pixeltype | isoutdb | file | outdbbandnum
---------+-----------+---------+---------------+--------------
1 | 8BUI | t | Projected.tif | 1
3 | 8BUI | t | Projected.tif | 3
2 | 8BUI | t | Projected.tif | 2ST_BandNoDataValue — Returnerar värdet i ett givet band som inte representerar några data. Om inget band finns antas siffran 1.
double precision ST_BandNoDataValue(raster rast, integer bandnum=1);
Returnerar det värde som representerar ingen data för bandet
SELECT ST_BandNoDataValue(rast, 1) As bnval1,
ST_BandNoDataValue(rast, 2) As bnval2, ST_BandNoDataValue(rast, 3) As bnval3
FROM dummy_rast
WHERE rid = 2;bnval1 | bnval2 | bnval3
--------+--------+--------
0 | 0 | 0ST_BandIsNoData — Returnerar true om bandet är fyllt med endast nodata-värden.
boolean ST_BandIsNoData(raster rast, integer band, boolean forceChecking=false);
boolean ST_BandIsNoData(raster rast, boolean forceChecking=false);
Returnerar true om bandet är fyllt med endast nodata-värden. Band 1 antas om det inte anges. Om det sista argumentet är TRUE kontrolleras hela bandet pixel för pixel. I annat fall returnerar funktionen helt enkelt värdet på isnodata-flaggan för bandet. Standardvärdet för denna parameter är FALSE, om den inte anges.
Tillgänglighet: 2.0.0
![]() | |
If the flag is dirty (this is, the result is different using TRUE as last parameter and not using it) you should update the raster to set this flag to true, by using ST_SetBandIsNoData(), or ST_SetBandNoDataValue() with TRUE as last argument. See ST_SetBandIsNoData. |
This example creates a dummy table with one raster column. The raster has two bands and one pixel per band. In the first band, the NODATA value and pixel value are both 3. In the second band, the NODATA value is 13 and the pixel value is 4.
create table dummy_rast (rid integer, rast raster);
insert into dummy_rast values(
1,
(
'01' -- little endian (uint8 ndr)
||
'0000' -- version (uint16 0)
||
'0200' -- nBands (uint16 0)
||
'17263529ED684A3F' -- scaleX (float64 0.000805965234044584)
||
'F9253529ED684ABF' -- scaleY (float64 -0.00080596523404458)
||
'1C9F33CE69E352C0' -- ipX (float64 -75.5533328537098)
||
'718F0E9A27A44840' -- ipY (float64 49.2824585505576)
||
'ED50EB853EC32B3F' -- skewX (float64 0.000211812383858707)
||
'7550EB853EC32B3F' -- skewY (float64 0.000211812383858704)
||
'E6100000' -- SRID (int32 4326)
||
'0100' -- width (uint16 1)
||
'0100' -- height (uint16 1)
||
'6' -- hasnodatavalue and isnodata value set to true.
||
'2' -- first band type (4BUI)
||
'03' -- novalue==3
||
'03' -- pixel(0,0)==3 (same that nodata)
||
'0' -- hasnodatavalue set to false
||
'5' -- second band type (16BSI)
||
'0D00' -- novalue==13
||
'0400' -- pixel(0,0)==4
)::raster
);
select ST_BandIsNoData(rast, 1) from dummy_rast where rid = 1; -- Expected true
select ST_BandIsNoData(rast, 2) from dummy_rast where rid = 1; -- Expected false
ST_BandPath — Returnerar systemfilens sökväg till ett band som finns lagrat i filsystemet. Om inget bandnummer anges antas 1.
text ST_BandPath(raster rast, integer bandnum=1);
Returnerar systemfilens sökväg till ett band. Kastar ett fel om det anropas med ett in db-band.
WITH foo AS (
SELECT ST_AddBand(
NULL::raster,
'/home/pele/devel/geo/postgis-git/raster/test/regress/loader/Projected.tif',
NULL::int[]
) AS rast
)
SELECT bandnum, ST_BandPath(rast, bandnum) AS path
FROM foo
CROSS JOIN generate_series(1, 3) AS bandnum;bandnum | path
---------+----------------------------------------------------------------------------
1 | /home/pele/devel/geo/postgis-git/raster/test/regress/loader/Projected.tif
2 | /home/pele/devel/geo/postgis-git/raster/test/regress/loader/Projected.tif
3 | /home/pele/devel/geo/postgis-git/raster/test/regress/loader/Projected.tifST_BandFileSize — Returnerar filstorleken för ett band som finns lagrat i filsystemet. Om inget bandnummer anges antas 1.
bigint ST_BandFileSize(raster rast, integer bandnum=1);
Returnerar filstorleken för ett band som lagras i filsystemet. Kastar ett fel om det anropas med ett in db-band, eller om outdb-åtkomst inte är aktiverad.
Denna funktion används vanligtvis tillsammans med ST_BandPath() och ST_BandFileTimestamp() så att en klient kan avgöra om filnamnet på ett outdb-raster som den ser är detsamma som det som servern ser.
Tillgänglighet: 2.5.0
SELECT ST_BandFileSize(rast, 1) FROM dummy_rast WHERE rid = 1;
240574
ST_BandFileTimestamp — Returnerar filens tidsstämpel för ett band som finns lagrat i filsystemet. Om inget bandnummer anges antas 1.
bigint ST_BandFileTimestamp(raster rast, integer bandnum=1);
Returnerar filens tidsstämpel (antal sekunder sedan 1 januari 1970 00:00:00 UTC) för ett band som lagras i filsystemet. Kastar ett fel om det anropas med ett in db-band, eller om outdb-åtkomst inte är aktiverad.
Denna funktion används vanligtvis tillsammans med ST_BandPath() och ST_BandFileSize() så att en klient kan avgöra om filnamnet på ett outdb-raster som den ser är detsamma som det som servern ser.
Tillgänglighet: 2.5.0
SELECT ST_BandFileTimestamp(rast, 1) FROM dummy_rast WHERE rid = 1;
1521807257
ST_BandPixelType — Returnerar pixeltyp för givet band. Om inget bandnummer anges antas 1.
text ST_BandPixelType(raster rast, integer bandnum=1);
Returnerar namn som beskriver datatyp och storlek på värden som lagras i varje cell i ett givet band.
Det finns 11 olika pixeltyper. Pixeltyper som stöds är följande:
1BB - 1-bitars boolean
2BUI - 2-bitars osignerat heltal
4BUI - 4-bitars osignerat heltal
8BSI - 8-bitars signerat heltal
8BUI - 8-bitars osignerat heltal
16BSI - 16-bitars signerat heltal
16BUI - 16-bitars osignerat heltal
32BSI - 32-bitars signerat heltal
32BUI - 32-bitars osignerat heltal
32BF - 32-bitars float
64BF - 64-bitars float
SELECT ST_BandPixelType(rast, 1) As btype1,
ST_BandPixelType(rast, 2) As btype2, ST_BandPixelType(rast, 3) As btype3
FROM dummy_rast
WHERE rid = 2;btype1 | btype2 | btype3 --------+--------+-------- 8BUI | 8BUI | 8BUI
ST_MinPossibleValue — Returnerar det lägsta värde som denna pixeltyp kan lagra.
integer ST_MinPossibleValue(text pixeltype);
Returnerar det lägsta värde som denna pixeltyp kan lagra.
SELECT ST_MinPossibleValue('16BSI');-32768
SELECT ST_MinPossibleValue('8BUI');0
ST_HasNoBand — Returnerar true om det inte finns något band med angivet bandnummer. Om inget bandnummer anges antas bandnummer 1.
boolean ST_HasNoBand(raster rast, integer bandnum=1);
Returnerar true om det inte finns något band med angivet bandnummer. Om inget bandnummer anges antas bandnummer 1.
Tillgänglighet: 2.0.0
SELECT rid, ST_HasNoBand(rast) As hb1, ST_HasNoBand(rast, 2) as hb2, ST_HasNoBand(rast, 4) as hb4, ST_NumBands(rast) As numbands FROM dummy_rast;
rid | hb1 | hb2 | hb4 | numbands -----+-----+-----+-----+---------- 1 | t | t | t | 0 2 | f | f | t | 3
exclude_nodata_value är satt till false, anses alla pixlar inklusive nodata-pixlar korsa varandra och returnerar värdet. Om värdet exclude_nodata_value inte anges läses det från rastrets metadata.icke-NODATA-värdet för ett givet bands pixel som anges av en kolumnx och rowy eller en geometrisk punkt uttryckt i samma spatiala referenskoordinatsystem som rastret. icke-NODATA-värden runt ett visst bands pixel som anges av antingen en kolumnX och radY eller en geometrisk punkt uttryckt i samma spatiala referenskoordinatsystem som rastret. ST_PixelAsPolygon — Returnerar den polygongeometri som avgränsar pixeln för en viss rad och kolumn.
geometry ST_PixelAsPolygon(raster rast, integer columnx, integer rowy);
Returnerar den polygongeometri som avgränsar pixeln för en viss rad och kolumn.
Tillgänglighet: 2.0.0
This example returns a raster pixel polygon.
SELECT i, j, ST_PixelAsPolygon(foo.rast, i, j) As b1pgeom
FROM dummy_rast As foo
CROSS JOIN generate_series(1, 2) As i
CROSS JOIN generate_series(1, 1) As j
WHERE rid=2;i | j | b1pgeom ---+---+----------------------------------------------------------------------------- 1 | 1 | POLYGON((3427927.75 5793244,3427927.8 5793244,3427927.8 5793243.95,... 2 | 1 | POLYGON((3427927.8 5793244,3427927.85 5793244,3427927.85 5793243.95, ..
ST_PixelAsPolygons — Returnerar den polygongeometri som avgränsar varje pixel i ett rasterband tillsammans med värdet, X- och Y-rasterkoordinaterna för varje pixel.
setof record ST_PixelAsPolygons(raster rast, integer band=1, boolean exclude_nodata_value=TRUE);
Returnerar den polygongeometri som avgränsar varje pixel i ett rasterband tillsammans med värdet (dubbel precision), X- och Y-rasterkoordinaterna (heltal) för varje pixel.
Format för returpost: geom geometry, val dubbel precision, x heltal, y heltal.
![]() | |
When |
Tillgänglighet: 2.0.0
Förbättrad: 2.1.0 exclude_nodata_value valfritt argument lades till.
Ändrad: 2.1.1 Ändrat beteende för exclude_nodata_value.
This example returns a raster pixel polygon.
WITH raster AS (
SELECT ST_SetValue(
ST_SetValue(
ST_AddBand(
ST_MakeEmptyRaster(
2, 2, 0, 0, 0.001, -0.001, 0.001, 0.001, 4269
),
1, '8BUI', 1, 0
),
2, 2, 10
),
1, 1, NULL
) AS rast
), pixels AS (
SELECT (ST_PixelAsPolygons(rast)).*
FROM raster
)
SELECT x, y, val, geom AS geom
FROM pixels
ORDER BY x, y;x | y | val | geom ---+---+----------------------------------------------------------------------------- 1 | 2 | 1 | POLYGON((0.001 -0.001,0.002 0,0.003 -0.001,0.002 -0.002,0.001 -0.001)) 2 | 1 | 1 | POLYGON((0.001 0.001,0.002 0.002,0.003 0.001,0.002 0,0.001 0.001)) 2 | 2 | 10 | POLYGON((0.002 0,0.003 0.001,0.004 0,0.003 -0.001,0.002 0))
ST_PixelAsPoint — Returnerar en punktgeometri för pixelns övre vänstra hörn.
geometry ST_PixelAsPoint(raster rast, integer columnx, integer rowy);
Returnerar en punktgeometri för pixelns övre vänstra hörn.
Tillgänglighet: 2.1.0
SELECT ST_PixelAsPoint(rast, 1, 1) FROM dummy_rast WHERE rid = 1;
POINT(0.5 0.5)
ST_PixelAsPoints — Returnerar en punktgeometri för varje pixel i ett rasterband tillsammans med värdet, X- och Y-rasterkoordinaterna för varje pixel. Punktgeometrins koordinater är pixelns övre vänstra hörn.
setof record ST_PixelAsPoints(raster rast, integer band=1, boolean exclude_nodata_value=TRUE);
Returnerar en punktgeometri för varje pixel i ett rasterband tillsammans med värdet, X- och Y-rasterkoordinaterna för varje pixel. Punktgeometrins koordinater är pixelns övre vänstra hörn.
Format för returpost: geom geometry, val dubbel precision, x heltal, y heltal.
![]() | |
När |
Tillgänglighet: 2.1.0
Ändrad: 2.1.1 Ändrat beteende för exclude_nodata_value.
This example returns point features together with a derived marker size that a client can use for value-scaled point rendering.
SELECT
x,
y,
val,
round((val / 32.0)::numeric, 2) AS marker_scale,geom AS geom
FROM (
SELECT (ST_PixelAsPoints(rast, 1)).*
FROM dummy_rast
WHERE rid = 2
) AS foo
ORDER BY y, x;x | y | val | marker_scale | geom ---+---+-----+--------------+------------------------------ 1 | 1 | 253 | 7.91 | POINT(3427927.75 5793244) 2 | 1 | 254 | 7.94 | POINT(3427927.8 5793244) 3 | 1 | 253 | 7.91 | POINT(3427927.85 5793244) 4 | 1 | 254 | 7.94 | POINT(3427927.9 5793244) 5 | 1 | 254 | 7.94 | POINT(3427927.95 5793244) 1 | 2 | 253 | 7.91 | POINT(3427927.75 5793243.95) 2 | 2 | 254 | 7.94 | POINT(3427927.8 5793243.95) 3 | 2 | 254 | 7.94 | POINT(3427927.85 5793243.95) 4 | 2 | 253 | 7.91 | POINT(3427927.9 5793243.95) 5 | 2 | 249 | 7.78 | POINT(3427927.95 5793243.95) 1 | 3 | 250 | 7.81 | POINT(3427927.75 5793243.9) 2 | 3 | 254 | 7.94 | POINT(3427927.8 5793243.9) 3 | 3 | 254 | 7.94 | POINT(3427927.85 5793243.9) 4 | 3 | 252 | 7.88 | POINT(3427927.9 5793243.9) 5 | 3 | 249 | 7.78 | POINT(3427927.95 5793243.9) 1 | 4 | 251 | 7.84 | POINT(3427927.75 5793243.85) 2 | 4 | 253 | 7.91 | POINT(3427927.8 5793243.85) 3 | 4 | 254 | 7.94 | POINT(3427927.85 5793243.85) 4 | 4 | 254 | 7.94 | POINT(3427927.9 5793243.85) 5 | 4 | 253 | 7.91 | POINT(3427927.95 5793243.85) 1 | 5 | 252 | 7.88 | POINT(3427927.75 5793243.8) 2 | 5 | 250 | 7.81 | POINT(3427927.8 5793243.8) 3 | 5 | 254 | 7.94 | POINT(3427927.85 5793243.8) 4 | 5 | 254 | 7.94 | POINT(3427927.9 5793243.8) 5 | 5 | 254 | 7.94 | POINT(3427927.95 5793243.8)
ST_PixelAsCentroid — Returnerar centroiden (punktgeometri) för det område som representeras av en pixel.
geometry ST_PixelAsCentroid(raster rast, integer x, integer y);
Returnerar centroiden (punktgeometri) för det område som representeras av en pixel.
Förbättrad: 3.2.0 Snabbare nu implementerad i C.
Tillgänglighet: 2.1.0
SELECT ST_PixelAsCentroid(rast, 1, 1) FROM dummy_rast WHERE rid = 1;
POINT(1.5 2)
ST_PixelAsCentroids — Returnerar centroiden (punktgeometri) för varje pixel i ett rasterband tillsammans med värdet, X- och Y-rasterkoordinaterna för varje pixel. Punktgeometrin är centroiden för det område som representeras av en pixel.
setof record ST_PixelAsCentroids(raster rast, integer band=1, boolean exclude_nodata_value=TRUE);
Returnerar centroiden (punktgeometri) för varje pixel i ett rasterband tillsammans med värdet, X- och Y-rasterkoordinaterna för varje pixel. Punktgeometrin är centroiden för det område som representeras av en pixel.
Format för returpost: geom geometry, val dubbel precision, x heltal, y heltal.
![]() | |
När |
Förbättrad: 3.2.0 Snabbare nu implementerad i C.
Ändrad: 2.1.1 Ändrat beteende för exclude_nodata_value.
Tillgänglighet: 2.1.0
This example uses LATERAL syntax.
SELECT x, y, val,geom
FROM (SELECT dp.* FROM dummy_rast, LATERAL ST_PixelAsCentroids(rast, 1) AS dp WHERE rid = 2) foo;x | y | val | st_astext ---+---+-----+-------------------------------- 1 | 1 | 253 | POINT(3427927.775 5793243.975) 2 | 1 | 254 | POINT(3427927.825 5793243.975) 3 | 1 | 253 | POINT(3427927.875 5793243.975) 4 | 1 | 254 | POINT(3427927.925 5793243.975) 5 | 1 | 254 | POINT(3427927.975 5793243.975) 1 | 2 | 253 | POINT(3427927.775 5793243.925) 2 | 2 | 254 | POINT(3427927.825 5793243.925) 3 | 2 | 254 | POINT(3427927.875 5793243.925) 4 | 2 | 253 | POINT(3427927.925 5793243.925) 5 | 2 | 249 | POINT(3427927.975 5793243.925) 1 | 3 | 250 | POINT(3427927.775 5793243.875) 2 | 3 | 254 | POINT(3427927.825 5793243.875) 3 | 3 | 254 | POINT(3427927.875 5793243.875) 4 | 3 | 252 | POINT(3427927.925 5793243.875) 5 | 3 | 249 | POINT(3427927.975 5793243.875) 1 | 4 | 251 | POINT(3427927.775 5793243.825) 2 | 4 | 253 | POINT(3427927.825 5793243.825) 3 | 4 | 254 | POINT(3427927.875 5793243.825) 4 | 4 | 254 | POINT(3427927.925 5793243.825) 5 | 4 | 253 | POINT(3427927.975 5793243.825) 1 | 5 | 252 | POINT(3427927.775 5793243.775) 2 | 5 | 250 | POINT(3427927.825 5793243.775) 3 | 5 | 254 | POINT(3427927.875 5793243.775) 4 | 5 | 254 | POINT(3427927.925 5793243.775) 5 | 5 | 254 | POINT(3427927.975 5793243.775)
ST_Value — Returnerar värdet för ett visst band i en viss kolumnx, radpixel eller vid en viss geometrisk punkt. Bandnummer börjar på 1 och antas vara 1 om det inte anges. Om exclude_nodata_value är satt till false, anses alla pixlar inklusive nodata-pixlar korsa varandra och returnerar värdet. Om värdet exclude_nodata_value inte anges läses det från rastrets metadata.
double precision ST_Value(raster rast, geometry pt, boolean exclude_nodata_value=true);
double precision ST_Value(raster rast, integer band, geometry pt, boolean exclude_nodata_value=true, text resample='nearest');
double precision ST_Value(raster rast, integer x, integer y, boolean exclude_nodata_value=true);
double precision ST_Value(raster rast, integer band, integer x, integer y, boolean exclude_nodata_value=true);
Returnerar värdet för ett givet band i en given kolumnx, radpixel eller vid en given geometripunkt. Bandnummer börjar på 1 och band antas vara 1 om det inte specificeras.
Om värdet exclude_nodata_value är satt till true beaktas endast pixlar som inte är nodata. Om värdet exclude_nodata_value är satt till false beaktas alla pixlar.
The allowed values of the resample parameter are "nearest" which performs the default nearest-neighbor resampling, "bilinear" which performs a bilinear interpolation to estimate the value between pixel centers, and the nearest-neighbor boundary options "nearest-UL", "nearest-UR", "nearest-LL", and "nearest-LR". Boundary options choose which pixel is returned when the point lies on a horizontal or vertical pixel boundary, including corner intersections.
Enhanced: 3.7.0 resample accepts nearest-neighbor boundary options "nearest-UL", "nearest-UR", "nearest-LL", and "nearest-LR".
Förbättrad: 3.2.0 resample valfritt argument lades till.
Förbättrad: 2.0.0 exclude_nodata_value valfritt argument lades till.
Get raster values at particular postgis geometry points. The srid of your geometry should be same as for your raster.
SELECT rid, ST_Value(rast, foo.pt_geom) As b1pval, ST_Value(rast, 2, foo.pt_geom) As b2pval FROM dummy_rast CROSS JOIN (SELECT ST_SetSRID(ST_Point(3427927.77, 5793243.76), 0) As pt_geom) As foo WHERE rid=2;
rid | b1pval | b2pval -----+--------+-------- 2 | 252 | 79
General fictitious example using a real table.
SELECT rid, ST_Value(rast, 3, sometable.geom) As b3pval FROM sometable WHERE ST_Intersects(rast, sometable.geom);
SELECT rid, ST_Value(rast, 1, 1, 1) As b1pval,
ST_Value(rast, 2, 1, 1) As b2pval, ST_Value(rast, 3, 1, 1) As b3pval
FROM dummy_rast
WHERE rid=2;rid | b1pval | b2pval | b3pval -----+--------+--------+-------- 2 | 253 | 78 | 70
Get all values in bands 1,2,3 of each pixel.
SELECT x, y, ST_Value(rast, 1, x, y) As b1val,
ST_Value(rast, 2, x, y) As b2val, ST_Value(rast, 3, x, y) As b3val
FROM dummy_rast CROSS JOIN
generate_series(1, 1000) As x CROSS JOIN generate_series(1, 1000) As y
WHERE rid = 2 AND x <= ST_Width(rast) AND y <= ST_Height(rast);x | y | b1val | b2val | b3val ---+---+-------+-------+------- 1 | 1 | 253 | 78 | 70 1 | 2 | 253 | 96 | 80 1 | 3 | 250 | 99 | 90 1 | 4 | 251 | 89 | 77 1 | 5 | 252 | 79 | 62 2 | 1 | 254 | 98 | 86 2 | 2 | 254 | 118 | 108 : :
Get all values in bands 1,2,3 of each pixel same as above but returning the upper left point point of each pixel.
SELECT ST_SetSRID(ST_Point(ST_UpperLeftX(rast) + ST_ScaleX(rast)*x,
ST_UpperLeftY(rast) + ST_ScaleY(rast)*y),
ST_SRID(rast)) As uplpt,
ST_Value(rast, 1, x, y) As b1val,
ST_Value(rast, 2, x, y) As b2val, ST_Value(rast, 3, x, y) As b3val
FROM dummy_rast CROSS JOIN
generate_series(1,1000) As x CROSS JOIN generate_series(1,1000) As y
WHERE rid = 2 AND x <= ST_Width(rast) AND y <= ST_Height(rast);uplpt | b1val | b2val | b3val -----------------------------+-------+-------+------- POINT(3427929.25 5793245.5) | 253 | 78 | 70 POINT(3427929.25 5793247) | 253 | 96 | 80 POINT(3427929.25 5793248.5) | 250 | 99 | 90 :
Get a polygon formed by union of all pixels that fall in a particular value range and intersect a particular polygon.
SELECT ST_Union(pixpolyg) As shadow
FROM (SELECT ST_Translate(ST_MakeEnvelope(ST_UpperLeftX(rast), ST_UpperLeftY(rast),
ST_UpperLeftX(rast) + ST_ScaleX(rast),
ST_UpperLeftY(rast) + ST_ScaleY(rast), 0
), ST_ScaleX(rast)*x, ST_ScaleY(rast)*y
) As pixpolyg, ST_Value(rast, 2, x, y) As b2val
FROM dummy_rast CROSS JOIN
generate_series(1,1000) As x CROSS JOIN generate_series(1,1000) As y
WHERE rid = 2
AND x <= ST_Width(rast) AND y <= ST_Height(rast)) As foo
WHERE
ST_Intersects(
pixpolyg,
ST_GeomFromText('POLYGON((3427928 5793244,3427927.75 5793243.75,3427928 5793243.75,3427928 5793244))',0)
) AND b2val != 254;
shadow
------------------------------------------------------------------------------------
MULTIPOLYGON(((3427928 5793243.9,3427928 5793243.85,3427927.95 5793243.85,3427927.95 5793243.9,
3427927.95 5793243.95,3427928 5793243.95,3427928.05 5793243.95,3427928.05 5793243.9,3427928 5793243.9)),((3427927.95 5793243.9,3427927.95 579324
3.85,3427927.9 5793243.85,3427927.85 5793243.85,3427927.85 5793243.9,3427927.9 5793243.9,3427927.9 5793243.95,
3427927.95 5793243.95,3427927.95 5793243.9)),((3427927.85 5793243.75,3427927.85 5793243.7,3427927.8 5793243.7,3427927.8 5793243.75,
3427927.8 5793243.8,3427927.8 5793243.85,3427927.85 5793243.85,3427927.85 5793243.8,3427927.85 5793243.75)),
((3427928.05 5793243.75,3427928.05 5793243.7,3427928 5793243.7,3427927.95 5793243.7,3427927.95 5793243.75,3427927.95 5793243.8,3427
927.95 5793243.85,3427928 5793243.85,3427928 5793243.8,3427928.05 5793243.8,
3427928.05 5793243.75)),((3427927.95 5793243.75,3427927.95 5793243.7,3427927.9 5793243.7,3427927.85 5793243.7,
3427927.85 5793243.75,3427927.85 5793243.8,3427927.85 5793243.85,3427927.9 5793243.85,
3427927.95 5793243.85,3427927.95 5793243.8,3427927.95 5793243.75)))
Checking all the pixels of a large raster tile can take a long time. You can dramatically improve speed at some lose of precision by orders of magnitude. By sampling pixels using the step optional parameter of generate_series. This next example does the same as previous but by checking 1 for every 4 (2x2) pixels and putting in the last checked. Putting in the checked pixel as the value for subsequent 4.
SELECT ST_Union(pixpolyg) As shadow
FROM (SELECT ST_Translate(ST_MakeEnvelope(ST_UpperLeftX(rast), ST_UpperLeftY(rast),
ST_UpperLeftX(rast) + ST_ScaleX(rast)*2,
ST_UpperLeftY(rast) + ST_ScaleY(rast)*2, 0
), ST_ScaleX(rast)*x, ST_ScaleY(rast)*y
) As pixpolyg, ST_Value(rast, 2, x, y) As b2val
FROM dummy_rast CROSS JOIN
generate_series(1,1000,2) As x CROSS JOIN generate_series(1,1000,2) As y
WHERE rid = 2
AND x <= ST_Width(rast) AND y <= ST_Height(rast) ) As foo
WHERE
ST_Intersects(
pixpolyg,
ST_GeomFromText('POLYGON((3427928 5793244,3427927.75 5793243.75,3427928 5793243.75,3427928 5793244))',0)
) AND b2val != 254;
shadow
------------------------------------------------------------------------------------
MULTIPOLYGON(((3427927.9 5793243.85,3427927.8 5793243.85,3427927.8 5793243.95,
3427927.9 5793243.95,3427928 5793243.95,3427928.1 5793243.95,3427928.1 5793243.85,3427928 5793243.85,3427927.9 5793243.85)),
((3427927.9 5793243.65,3427927.8 5793243.65,3427927.8 5793243.75,3427927.8 5793243.85,3427927.9 5793243.85,
3427928 5793243.85,3427928 5793243.75,3427928.1 5793243.75,3427928.1 5793243.65,3427928 5793243.65,3427927.9 5793243.65)))
ST_NearestValue — Returnerar det närmaste icke-NODATA-värdet för ett givet bands pixel som anges av en kolumnx och rowy eller en geometrisk punkt uttryckt i samma spatiala referenskoordinatsystem som rastret.
double precision ST_NearestValue(raster rast, integer bandnum, geometry pt, boolean exclude_nodata_value=true);
double precision ST_NearestValue(raster rast, geometry pt, boolean exclude_nodata_value=true);
double precision ST_NearestValue(raster rast, integer bandnum, integer columnx, integer rowy, boolean exclude_nodata_value=true);
double precision ST_NearestValue(raster rast, integer columnx, integer rowy, boolean exclude_nodata_value=true);
Returnerar det närmaste icke-NODATA-värdet för ett givet band i en given kolumnx, rowy-pixel eller i en specifik geometrisk punkt. Om pixeln i kolumnx, rowy eller pixeln i den angivna geometriska punkten är NODATA, kommer funktionen att hitta den närmaste pixeln till pixeln i kolumnx, rowy eller den geometriska punkten vars värde inte är NODATA.
Bandnumren börjar på 1 och bandnum antas vara 1 om det inte anges. Om exclude_nodata_value är satt till false anses alla pixlar inklusive nodata-pixlar skära varandra och returnerar värdet. Om värdet exclude_nodata_value inte anges läses det från rastrets metadata.
Tillgänglighet: 2.1.0
![]() | |
ST_NearestValue är en drop-in-ersättning för ST_Value. |
This example reads a value from pixel 2x2.
WITH source AS (
SELECT ST_SetValues(
ST_AddBand(
ST_MakeEmptyRaster(5, 5, -2, 2, 1, -1, 0, 0, 0),
1, '8BUI', 1, 0
),
1, 1, 1,
ARRAY[
[0, 1, 1, 1, 1],
[1, 1, 1, 0, 1],
[1, 0, 1, 1, 1],
[1, 1, 1, 1, 0],
[1, 1, 0, 1, 1]
]::double precision[][]
) AS rast
)
SELECT
ST_Value(rast, 2, 2) AS value,
ST_NearestValue(rast, 2, 2) AS nearestvalue
FROM sourcevalue | nearestvalue
-------+--------------
1 | 1This example reads a NODATA value from pixel 2x3.
WITH source AS (
SELECT ST_SetValues(
ST_AddBand(
ST_MakeEmptyRaster(5, 5, -2, 2, 1, -1, 0, 0, 0),
1, '8BUI', 1, 0
),
1, 1, 1,
ARRAY[
[0, 1, 1, 1, 1],
[1, 1, 1, 0, 1],
[1, 0, 1, 1, 1],
[1, 1, 1, 1, 0],
[1, 1, 0, 1, 1]
]::double precision[][]
) AS rast
)
SELECT
ST_Value(rast, 2, 3) AS value,
ST_NearestValue(rast, 2, 3) AS nearestvalue
FROM sourcevalue | nearestvalue
-------+--------------
| 1ST_SetZ — Returnerar en geometri med samma X/Y-koordinater som indatageometrin, och värden från rastret kopierade till Z-dimensionen med hjälp av den begärda resample-algoritmen.
geometry ST_SetZ(raster rast, geometry geom, text resample=nearest, integer band=1);
Returnerar en geometri med samma X/Y-koordinater som indatageometrin, och värden från rastret kopieras till Z-dimensionerna med hjälp av den begärda resample-algoritmen.
Parametern resample kan ställas in på "nearest" för att kopiera värdena från den cell som varje vertex faller inom, eller "bilinear" för att använda bilineär interpolation för att beräkna ett värde som även tar hänsyn till angränsande celler.
Tillgänglighet: 3.2.0
2x2 test raster with values. 10 50. 40 20.
WITH test_raster AS (
SELECT
ST_SetValues(
ST_AddBand(
ST_MakeEmptyRaster(
width => 2,
height => 2,
upperleftx => 0,
upperlefty => 2,
scalex => 1.0,
scaley => -1.0,
skewx => 0,
skewy => 0,
srid => 4326),
index => 1,
pixeltype => '16BSI',
initialvalue => 0,
nodataval => -999
),
1,
1,
1,
newvalueset => ARRAY[ARRAY[10.0::float8, 50.0::float8], ARRAY[40.0::float8, 20.0::float8]]) AS rast
)
SELECT
ST_SetZ(
rast,
band => 1,
geom => 'SRID=4326;LINESTRING(1.0 1.9,1.0 0.2)'::geometry,
resample => 'bilinear'
)
FROM test_rasterLINESTRING Z (1 1.9 38,1 0.2 27)
ST_SetM — Returnerar en geometri med samma X/Y-koordinater som indatageometrin, och värden från rastret kopierade till M-dimensionen med hjälp av den begärda resample-algoritmen.
geometry ST_SetM(raster rast, geometry geom, text resample=nearest, integer band=1);
Returnerar en geometri med samma X/Y-koordinater som indatageometrin, och värden från rastret kopierade till M-dimensionerna med hjälp av den begärda resample-algoritmen.
Parametern resample kan ställas in på "nearest" för att kopiera värdena från den cell som varje vertex faller inom, eller "bilinear" för att använda bilineär interpolation för att beräkna ett värde som även tar hänsyn till angränsande celler.
Tillgänglighet: 3.2.0
2x2 test raster with values. 10 50. 40 20.
WITH test_raster AS (
SELECT
ST_SetValues(
ST_AddBand(
ST_MakeEmptyRaster(
width => 2,
height => 2,
upperleftx => 0,
upperlefty => 2,
scalex => 1.0,
scaley => -1.0,
skewx => 0,
skewy => 0,
srid => 4326),
index => 1,
pixeltype => '16BSI',
initialvalue => 0,
nodataval => -999
),
1,
1,
1,
newvalueset => ARRAY[ARRAY[10.0::float8, 50.0::float8], ARRAY[40.0::float8, 20.0::float8]]) AS rast
)
SELECT
ST_SetM(
rast,
band => 1,
geom => 'SRID=4326;LINESTRING(1.0 1.9,1.0 0.2)'::geometry,
resample => 'bilinear'
)
FROM test_rasterLINESTRING M (1 1.9 38,1 0.2 27)
ST_Neighborhood — Returnerar en 2D-array med dubbel precision av icke-NODATA-värden runt ett visst bands pixel som anges av antingen en kolumnX och radY eller en geometrisk punkt uttryckt i samma spatiala referenskoordinatsystem som rastret.
double precision[][] ST_Neighborhood(raster rast, integer bandnum, integer columnX, integer rowY, integer distanceX, integer distanceY, boolean exclude_nodata_value=true);
double precision[][] ST_Neighborhood(raster rast, integer columnX, integer rowY, integer distanceX, integer distanceY, boolean exclude_nodata_value=true);
double precision[][] ST_Neighborhood(raster rast, integer bandnum, geometry pt, integer distanceX, integer distanceY, boolean exclude_nodata_value=true);
double precision[][] ST_Neighborhood(raster rast, geometry pt, integer distanceX, integer distanceY, boolean exclude_nodata_value=true);
Returnerar en 2D-array med dubbel precision av icke-NODATA-värdena runt ett visst bands pixel som anges av antingen en kolumnX och radY eller en geometrisk punkt uttryckt i samma spatiala referenskoordinatsystem som rastret. Parametrarna distanceX och distanceY definierar antalet pixlar runt den angivna pixeln i X- och Y-axlarna, t.ex. vill jag ha alla värden inom 3 pixlars avstånd längs X-axeln och 2 pixlars avstånd längs Y-axeln runt min intressanta pixel. Centrumvärdet för 2D-arrayen kommer att vara värdet på den pixel som anges av kolumnX och radY eller den geometriska punkten.
Bandnumren börjar på 1 och bandnum antas vara 1 om det inte anges. Om exclude_nodata_value är satt till false anses alla pixlar inklusive nodata-pixlar skära varandra och returnerar värdet. Om värdet exclude_nodata_value inte anges läses det från rastrets metadata.
![]() | |
Antalet element längs varje axel i den returnerande 2D-arrayen är 2 * |
![]() | |
Utdata från 2D-arrayen kan skickas till någon av de inbyggda funktionerna för rasterbearbetning, t.ex. ST_Min4ma, ST_Sum4ma, ST_Mean4ma. |
Tillgänglighet: 2.1.0
This example reads a value from pixel 2x2.
SELECT
ST_Neighborhood(rast, 2, 2, 1, 1)
FROM (
SELECT
ST_SetValues(ST_AddBand(ST_MakeEmptyRaster(5, 5, -2, 2, 1, -1, 0, 0, 0),
'8BUI'::text, 1, 0
),
1, 1, 1, ARRAY[
[0, 1, 1, 1, 1],
[1, 1, 1, 0, 1],
[1, 0, 1, 1, 1],
[1, 1, 1, 1, 0],
[1, 1, 0, 1, 1]
]::double precision[],
1
) AS rast
) AS foo{{NULL,1,1},{1,1,1},{1,NULL,1}}This example reads a NODATA value from pixel 2x3.
SELECT
ST_Neighborhood(rast, 2, 3, 1, 1)
FROM (
SELECT
ST_SetValues(ST_AddBand(ST_MakeEmptyRaster(5, 5, -2, 2, 1, -1, 0, 0, 0),
'8BUI'::text, 1, 0
),
1, 1, 1, ARRAY[
[0, 1, 1, 1, 1],
[1, 1, 1, 0, 1],
[1, 0, 1, 1, 1],
[1, 1, 1, 1, 0],
[1, 1, 0, 1, 1]
]::double precision[],
1
) AS rast
) AS foo{{1,1,1},{1,NULL,1},{1,1,1}}Pixel 3x3 has value. Exclude_nodata_value = FALSE.
SELECT
ST_Neighborhood(rast, 3, 3, 1, 1, false)
FROM ST_SetValues(ST_AddBand(ST_MakeEmptyRaster(5, 5, -2, 2, 1, -1, 0, 0, 0),
'8BUI'::text, 1, 0
),
1, 1, 1, ARRAY[
[0, 1, 1, 1, 1],
[1, 1, 1, 0, 1],
[1, 0, 1, 1, 1],
[1, 1, 1, 1, 0],
[1, 1, 0, 1, 1]
]::double precision[],
1
) AS rast{{1,1,0},{0,1,1},{1,1,1}}ST_SetValue — Returnerar modifierad raster som är resultatet av att värdet för ett givet band har ställts in i en given kolumnx, radpixel eller de pixlar som skär en viss geometri. Bandnummer börjar på 1 och antas vara 1 om de inte specificeras.
raster ST_SetValue(raster rast, integer bandnum, geometry geom, double precision newvalue);
raster ST_SetValue(raster rast, geometry geom, double precision newvalue);
raster ST_SetValue(raster rast, integer bandnum, integer columnx, integer rowy, double precision newvalue);
raster ST_SetValue(raster rast, integer columnx, integer rowy, double precision newvalue);
Returnerar modifierat raster som är resultatet av att de angivna pixlarnas värden sätts till nytt värde för det angivna bandet givet rastrets rad och kolumn eller en geometri. Om inget band anges antas band 1.
Förbättrad: 2.1.0 Geometrivarianten av ST_SetValue() stöder nu alla geometrityper, inte bara punkt. Geometrivarianten är ett omslag runt geomval[]-varianten av ST_SetValues()
This example uses geometry input.
SELECT (foo.geomval).val, ST_Union((foo.geomval).geom)
FROM (SELECT ST_DumpAsPolygons(ST_SetValue(
rast,
1,
ST_Point(3427927.75, 5793243.95),
50)
) As geomval
FROM dummy_rast
where rid = 2) As foo
WHERE (foo.geomval).val < 250
GROUP BY (foo.geomval).val;val | st_astext -----+------------------------------------------------------------------- 50 | POLYGON((3427927.75 5793244,3427927.75 5793243.95,3427927.8 579324 ... 249 | POLYGON((3427927.95 5793243.95,3427927.95 5793243.85,3427928 57932 ...
This example stores the changed raster.
UPDATE dummy_rast SET rast = ST_SetValue(rast, 1, ST_Point(3427927.75, 5793243.95), 100)
WHERE rid = 2 ;
ST_SetValues — Returnerar modifierat raster som är resultatet av att värdena för ett givet band har ställts in.
raster ST_SetValues(raster rast, integer nband, integer columnx, integer rowy, double precision[][] newvalueset, boolean[][] noset=NULL, boolean keepnodata=FALSE);
raster ST_SetValues(raster rast, integer nband, integer columnx, integer rowy, double precision[][] newvalueset, double precision nosetvalue, boolean keepnodata=FALSE);
raster ST_SetValues(raster rast, integer nband, integer columnx, integer rowy, integer width, integer height, double precision newvalue, boolean keepnodata=FALSE);
raster ST_SetValues(raster rast, integer columnx, integer rowy, integer width, integer height, double precision newvalue, boolean keepnodata=FALSE);
raster ST_SetValues(raster rast, integer nband, geomval[] geomvalset, boolean keepnodata=FALSE);
Returnerar modifierat raster som är resultatet av att angivna pixlar har satts till nya värden för det angivna bandet. columnx och rowy är 1-indexerade.
Om keepnodata är TRUE kommer de pixlar vars värden är NODATA inte att förses med motsvarande värde i newvalueset.
För variant 1 bestäms de specifika pixlarna som ska ställas in av kolumnx, rowy-pixelkoordinaterna och dimensionerna för newvalueset-arrayen. noset kan användas för att förhindra att pixlar med värden som finns i newvalueset ställs in (på grund av att PostgreSQL inte tillåter ragged / jagged arrays). Se exempel Variant 1.
Variant 2 är som variant 1 men med ett enkelt nosetvärde med dubbel precision i stället för en boolesk noset-array. Element i newvalueset med värdet nosetvalue hoppas över. Se exempel Variant 2.
För variant 3 bestäms de specifika pixlar som ska ställas in av pixelkoordinaterna för columnx, rowy, width och height. Se exempel Variant 3.
Variant 4 är densamma som variant 3 med undantaget att den förutsätter att det första bandets pixlar av rast kommer att ställas in.
För variant 5 används en matris med geomval för att bestämma vilka specifika pixlar som ska ställas in. Om alla geometrier i matrisen är av typen POINT eller MULTIPOINT använder funktionen en genväg där longituden och latituden för varje punkt används för att ställa in en pixel direkt. I annat fall konverteras geometrierna till raster och itereras sedan igenom i ett pass. Se exempel Variant 5.
Tillgänglighet: 2.1.0
Variant 1.
These examples pass FALSE for exclude_nodata_value so that every raster cell remains visible. NODATA cells display the band's NODATA value, which is 0 here.
Set the lower-right 2 by 2 block of a 3 by 3 raster to 9.
SELECT
(poly).x,
(poly).y,
(poly).val
FROM (
SELECT
ST_PixelAsPolygons(ST_SetValues(ST_AddBand(ST_MakeEmptyRaster(3, 3, 0, 0, 1, -1, 0, 0, 0),
1, '8BUI', 1, 0
),
1, 2, 2, ARRAY[[9, 9], [9, 9]]::double precision[][]
),
1, FALSE
) AS poly
) foo
ORDER BY 1, 2;x | y | val ---+---+----- 1 | 1 | 1 1 | 2 | 1 1 | 3 | 1 2 | 1 | 1 2 | 2 | 9 2 | 3 | 9 3 | 1 | 1 3 | 2 | 9 3 | 3 | 9
Replace the complete raster from an array; the central NULL becomes NODATA.
SELECT
(poly).x,
(poly).y,
(poly).val
FROM (
SELECT
ST_PixelAsPolygons(ST_SetValues(ST_AddBand(ST_MakeEmptyRaster(3, 3, 0, 0, 1, -1, 0, 0, 0),
1, '8BUI', 1, 0
),
1, 1, 1, ARRAY[[9, 9, 9], [9, NULL, 9], [9, 9, 9]]::double precision[][]
),
1, FALSE
) AS poly
) foo
ORDER BY 1, 2;x | y | val ---+---+----- 1 | 1 | 9 1 | 2 | 9 1 | 3 | 9 2 | 1 | 9 2 | 2 | 0 2 | 3 | 9 3 | 1 | 9 3 | 2 | 9 3 | 3 | 9
Use the noset mask to retain the left-middle source pixel while replacing the other cells.
SELECT
(poly).x,
(poly).y,
(poly).val
FROM (
SELECT
ST_PixelAsPolygons(ST_SetValues(ST_AddBand(ST_MakeEmptyRaster(3, 3, 0, 0, 1, -1, 0, 0, 0),
1, '8BUI', 1, 0
),
1, 1, 1,
ARRAY[[9, 9, 9], [9, NULL, 9], [9, 9, 9]]::double precision[][],
ARRAY[[false], [true]]::boolean[][]
),
1, FALSE
) AS poly
) foo
ORDER BY 1, 2;x | y | val ---+---+----- 1 | 1 | 9 1 | 2 | 1 1 | 3 | 9 2 | 1 | 9 2 | 2 | 0 2 | 3 | 9 3 | 1 | 9 3 | 2 | 9 3 | 3 | 9
With keepnodata enabled, an existing NODATA pixel is not overwritten.
SELECT
(poly).x,
(poly).y,
(poly).val
FROM (
SELECT
ST_PixelAsPolygons(ST_SetValues(ST_SetValue(ST_AddBand(ST_MakeEmptyRaster(3, 3, 0, 0, 1, -1, 0, 0, 0),
1, '8BUI', 1, 0
),
1, 1, 1, NULL
),
1, 1, 1,
ARRAY[[9, 9, 9], [9, NULL, 9], [9, 9, 9]]::double precision[][],
ARRAY[[false], [true]]::boolean[][],
TRUE
),
1, FALSE
) AS poly
) foo
ORDER BY 1, 2;x | y | val ---+---+----- 1 | 1 | 0 1 | 2 | 1 1 | 3 | 9 2 | 1 | 9 2 | 2 | 0 2 | 3 | 9 3 | 1 | 9 3 | 2 | 9 3 | 3 | 9
Variant 2.
Use -1 as the value that should not be written; only the lower-right 2 by 2 block changes.
SELECT
(poly).x,
(poly).y,
(poly).val
FROM (
SELECT
ST_PixelAsPolygons(ST_SetValues(ST_AddBand(ST_MakeEmptyRaster(3, 3, 0, 0, 1, -1, 0, 0, 0),
1, '8BUI', 1, 0
),
1, 1, 1, ARRAY[[-1, -1, -1], [-1, 9, 9], [-1, 9, 9]]::double precision[][], -1
),
1, FALSE
) AS poly
) foo
ORDER BY 1, 2;x | y | val ---+---+----- 1 | 1 | 1 1 | 2 | 1 1 | 3 | 1 2 | 1 | 1 2 | 2 | 9 2 | 3 | 9 3 | 1 | 1 3 | 2 | 9 3 | 3 | 9
The same update can use NULL as the value that should not be written.
SELECT
(poly).x,
(poly).y,
(poly).val
FROM (
SELECT
ST_PixelAsPolygons(ST_SetValues(ST_AddBand(ST_MakeEmptyRaster(3, 3, 0, 0, 1, -1, 0, 0, 0),
1, '8BUI', 1, 0
),
1, 1, 1, ARRAY[[NULL, NULL, NULL], [NULL, 9, 9], [NULL, 9, 9]]::double precision[][], NULL::double precision
),
1, FALSE
) AS poly
) foo
ORDER BY 1, 2;x | y | val ---+---+----- 1 | 1 | 1 1 | 2 | 1 1 | 3 | 1 2 | 1 | 1 2 | 2 | 9 2 | 3 | 9 3 | 1 | 1 3 | 2 | 9 3 | 3 | 9
Variant 3.
Set a 2 by 2 rectangle starting at column 2, row 2.
SELECT
(poly).x,
(poly).y,
(poly).val
FROM (
SELECT
ST_PixelAsPolygons(ST_SetValues(ST_AddBand(ST_MakeEmptyRaster(3, 3, 0, 0, 1, -1, 0, 0, 0),
1, '8BUI', 1, 0
),
1, 2, 2, 2, 2, 9
),
1, FALSE
) AS poly
) foo
ORDER BY 1, 2;x | y | val ---+---+----- 1 | 1 | 1 1 | 2 | 1 1 | 3 | 1 2 | 1 | 1 2 | 2 | 9 2 | 3 | 9 3 | 1 | 1 3 | 2 | 9 3 | 3 | 9
When keepnodata is true, the NODATA cell inside the rectangle remains unchanged.
SELECT
(poly).x,
(poly).y,
(poly).val
FROM (
SELECT
ST_PixelAsPolygons(ST_SetValues(ST_SetValue(ST_AddBand(ST_MakeEmptyRaster(3, 3, 0, 0, 1, -1, 0, 0, 0),
1, '8BUI', 1, 0
),
1, 2, 2, NULL
),
1, 2, 2, 2, 2, 9, TRUE
),
1, FALSE
) AS poly
) foo
ORDER BY 1, 2;x | y | val ---+---+----- 1 | 1 | 1 1 | 2 | 1 1 | 3 | 1 2 | 1 | 1 2 | 2 | 0 2 | 3 | 9 3 | 1 | 1 3 | 2 | 9 3 | 3 | 9
Variant 5.
WITH foo AS (
SELECT 1 AS rid, ST_AddBand(ST_MakeEmptyRaster(5, 5, 0, 0, 1, -1, 0, 0, 0), 1, '8BUI', 0, 0) AS rast
), bar AS (
SELECT 1 AS gid, 'SRID=0;POINT(2.5 -2.5)'::geometry geom UNION ALL
SELECT 2 AS gid, 'SRID=0;POLYGON((1 -1,4 -1,4 -4,1 -4,1 -1))'::geometry geom UNION ALL
SELECT 3 AS gid, 'SRID=0;POLYGON((0 0,5 0,5 -1,1 -1,1 -4,0 -4,0 0))'::geometry geom UNION ALL
SELECT 4 AS gid, 'SRID=0;MULTIPOINT(0 0,4 4,4 -4)'::geometry
), changed AS (
SELECT rid, gid, ST_SetValue(rast, 1, geom, gid) AS rast
FROM foo
CROSS JOIN bar
)
SELECT
rid,
gid,
y,
array_agg(ST_Value(rast, 1, x, y) ORDER BY x) AS values
FROM changed
CROSS JOIN generate_series(1, 5) AS x
CROSS JOIN generate_series(1, 5) AS y
GROUP BY rid, gid, y
ORDER BY rid, gid, y;rid | gid | y | values
-----+-----+---+----------------------------
1 | 1 | 1 | {NULL,NULL,NULL,NULL,NULL}
1 | 1 | 2 | {NULL,NULL,NULL,NULL,NULL}
1 | 1 | 3 | {NULL,NULL,1,NULL,NULL}
1 | 1 | 4 | {NULL,NULL,NULL,NULL,NULL}
1 | 1 | 5 | {NULL,NULL,NULL,NULL,NULL}
1 | 2 | 1 | {NULL,NULL,NULL,NULL,NULL}
1 | 2 | 2 | {NULL,2,2,2,NULL}
1 | 2 | 3 | {NULL,2,2,2,NULL}
1 | 2 | 4 | {NULL,2,2,2,NULL}
1 | 2 | 5 | {NULL,NULL,NULL,NULL,NULL}
1 | 3 | 1 | {3,3,3,3,3}
1 | 3 | 2 | {3,NULL,NULL,NULL,NULL}
1 | 3 | 3 | {3,NULL,NULL,NULL,NULL}
1 | 3 | 4 | {3,NULL,NULL,NULL,NULL}
1 | 3 | 5 | {NULL,NULL,NULL,NULL,NULL}
1 | 4 | 1 | {4,NULL,NULL,NULL,NULL}
1 | 4 | 2 | {NULL,NULL,NULL,NULL,NULL}
1 | 4 | 3 | {NULL,NULL,NULL,NULL,NULL}
1 | 4 | 4 | {NULL,NULL,NULL,NULL,NULL}
1 | 4 | 5 | {NULL,NULL,NULL,NULL,4}
(20 rows)Följande exempel visar att geomval senare i matrisen kan skriva över tidigare geomval
WITH foo AS (
SELECT 1 AS rid, ST_AddBand(ST_MakeEmptyRaster(5, 5, 0, 0, 1, -1, 0, 0, 0), 1, '8BUI', 0, 0) AS rast
), bar AS (
SELECT 1 AS gid, 'SRID=0;POINT(2.5 -2.5)'::geometry geom UNION ALL
SELECT 2 AS gid, 'SRID=0;POLYGON((1 -1,4 -1,4 -4,1 -4,1 -1))'::geometry geom UNION ALL
SELECT 3 AS gid, 'SRID=0;POLYGON((0 0,5 0,5 -1,1 -1,1 -4,0 -4,0 0))'::geometry geom UNION ALL
SELECT 4 AS gid, 'SRID=0;MULTIPOINT(0 0,4 4,4 -4)'::geometry
), changed AS (
SELECT ST_SetValues(
rast,
1,
ARRAY[
ROW((SELECT geom FROM bar WHERE gid = 1), 1),
ROW((SELECT geom FROM bar WHERE gid = 2), 2)
]::geomval[]
) AS rast
FROM foo
)
SELECT
y,
array_agg(ST_Value(rast, 1, x, y) ORDER BY x) AS values
FROM changed
CROSS JOIN generate_series(1, 5) AS x
CROSS JOIN generate_series(1, 5) AS y
GROUP BY y
ORDER BY y;y | values
---+----------------------------
1 | {NULL,NULL,NULL,NULL,NULL}
2 | {NULL,2,2,2,NULL}
3 | {NULL,2,2,2,NULL}
4 | {NULL,2,2,2,NULL}
5 | {NULL,NULL,NULL,NULL,NULL}
(5 rows)Detta exempel är motsatsen till det föregående exemplet
WITH foo AS (
SELECT 1 AS rid, ST_AddBand(ST_MakeEmptyRaster(5, 5, 0, 0, 1, -1, 0, 0, 0), 1, '8BUI', 0, 0) AS rast
), bar AS (
SELECT 1 AS gid, 'SRID=0;POINT(2.5 -2.5)'::geometry geom UNION ALL
SELECT 2 AS gid, 'SRID=0;POLYGON((1 -1,4 -1,4 -4,1 -4,1 -1))'::geometry geom UNION ALL
SELECT 3 AS gid, 'SRID=0;POLYGON((0 0,5 0,5 -1,1 -1,1 -4,0 -4,0 0))'::geometry geom UNION ALL
SELECT 4 AS gid, 'SRID=0;MULTIPOINT(0 0,4 4,4 -4)'::geometry
), changed AS (
SELECT ST_SetValues(
rast,
1,
ARRAY[
ROW((SELECT geom FROM bar WHERE gid = 2), 2),
ROW((SELECT geom FROM bar WHERE gid = 1), 1)
]::geomval[]
) AS rast
FROM foo
)
SELECT
y,
array_agg(ST_Value(rast, 1, x, y) ORDER BY x) AS values
FROM changed
CROSS JOIN generate_series(1, 5) AS x
CROSS JOIN generate_series(1, 5) AS y
GROUP BY y
ORDER BY y;y | values
---+----------------------------
1 | {NULL,NULL,NULL,NULL,NULL}
2 | {NULL,2,2,2,NULL}
3 | {NULL,2,1,2,NULL}
4 | {NULL,2,2,2,NULL}
5 | {NULL,NULL,NULL,NULL,NULL}
(5 rows)ST_DumpValues — Hämta värdena för det angivna bandet som en 2-dimensionell array.
setof record ST_DumpValues( raster rast , integer[] nband=NULL , boolean exclude_nodata_value=true );
double precision[][] ST_DumpValues( raster rast , integer nband , boolean exclude_nodata_value=true );
Hämta värdena för det angivna bandet som en 2-dimensionell array (första indexet är rad, andra är kolumn). Om nband är NULL eller inte anges bearbetas alla rasterband.
Tillgänglighet: 2.1.0
WITH foo AS (
SELECT ST_AddBand(ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(3, 3, 0, 0, 1, -1, 0, 0, 0), 1, '8BUI'::text, 1, 0), 2, '32BF'::text, 3, -9999), 3, '16BSI', 0, 0) AS rast
)
SELECT
(ST_DumpValues(rast)).*
FROM foo;nband | valarray
-------+------------------------------------------------------
1 | {{1,1,1},{1,1,1},{1,1,1}}
2 | {{3,3,3},{3,3,3},{3,3,3}}
3 | {{NULL,NULL,NULL},{NULL,NULL,NULL},{NULL,NULL,NULL}}
(3 rows)WITH foo AS (
SELECT ST_AddBand(ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(3, 3, 0, 0, 1, -1, 0, 0, 0), 1, '8BUI'::text, 1, 0), 2, '32BF'::text, 3, -9999), 3, '16BSI', 0, 0) AS rast
)
SELECT
(ST_DumpValues(rast, ARRAY[3, 1])).*
FROM foo;nband | valarray
-------+------------------------------------------------------
3 | {{NULL,NULL,NULL},{NULL,NULL,NULL},{NULL,NULL,NULL}}
1 | {{1,1,1},{1,1,1},{1,1,1}}
(2 rows)WITH foo AS (
SELECT ST_SetValue(ST_AddBand(ST_MakeEmptyRaster(3, 3, 0, 0, 1, -1, 0, 0, 0), 1, '8BUI', 1, 0), 1, 2, 5) AS rast
)
SELECT
(ST_DumpValues(rast, 1))[2][1]
FROM foo;5
ST_PixelOfValue — Hämta koordinaterna för kolumnx, rowy för den pixel vars värde är lika med sökvärdet.
setof record ST_PixelOfValue( raster rast , integer nband , double precision[] search , boolean exclude_nodata_value=true );
setof record ST_PixelOfValue( raster rast , double precision[] search , boolean exclude_nodata_value=true );
setof record ST_PixelOfValue( raster rast , integer nband , double precision search , boolean exclude_nodata_value=true );
setof record ST_PixelOfValue( raster rast , double precision search , boolean exclude_nodata_value=true );
Hämta koordinaterna för kolumnx och radwy för den pixel vars värde är lika med sökvärdet. Om inget band anges antas band 1.
Tillgänglighet: 2.1.0
WITH source AS (
SELECT ST_SetValues(
ST_AddBand(
ST_MakeEmptyRaster(5, 5, -2, 2, 1, -1, 0, 0, 0),
1, '8BUI', 1, 0
),
1, 1, 1,
ARRAY[
[0, 1, 1, 1, 1],
[1, 1, 1, 0, 1],
[1, 0, 1, 1, 1],
[1, 1, 1, 1, 255],
[1, 1, 0, 1, 1]
]::double precision[][]
) AS rast
)
SELECT (ST_PixelOfValue(rast, 1, ARRAY[1, 255])).*
FROM sourceval | x | y -----+---+--- 1 | 1 | 2 1 | 1 | 3 1 | 1 | 4 1 | 1 | 5 1 | 2 | 1 1 | 2 | 2 1 | 2 | 4 1 | 2 | 5 1 | 3 | 1 1 | 3 | 2 1 | 3 | 3 1 | 3 | 4 1 | 4 | 1 1 | 4 | 3 1 | 4 | 4 1 | 4 | 5 1 | 5 | 1 1 | 5 | 2 1 | 5 | 3 255 | 5 | 4 1 | 5 | 5
ST_SetGeoReference — Set Georeference 6 georeferensparametrar i ett enda anrop. Siffrorna ska separeras med vitt utrymme. Accepterar inmatningar i GDAL- eller ESRI-format. Standard är GDAL.
raster ST_SetGeoReference(raster rast, text georefcoords, text format=GDAL);
raster ST_SetGeoReference(raster rast, double precision upperleftx, double precision upperlefty, double precision scalex, double precision scaley, double precision skewx, double precision skewy);
Set Georeference 6 georeferensparametrar i ett enda anrop. Accepterar indata i "GDAL"- eller "ESRI"-format. Standard är GDAL. Om 6 koordinater inte anges kommer null att returneras.
Skillnaden mellan formatrepresentationer är följande:
GDAL uses the value order shown below.
scalex skewy skewx scaley upperleftx upperlefty
ESRI uses the value order shown below.
scalex skewy skewx scaley upperleftx + scalex*0.5 upperlefty + scaley*0.5
![]() | |
Om rastret har out-db-band kan en ändring av georeferensen leda till felaktig åtkomst till bandets externt lagrade data. |
Förbättrad: 2.1.0 Tillägg av varianten ST_SetGeoReference(raster, dubbel precision, ...)
WITH source AS (
SELECT ST_MakeEmptyRaster(5, 5, 0, 0, 1, -1, 0, 0, 0) AS rast
), variants AS (
SELECT 0 AS rid, rast FROM source
UNION ALL
SELECT 1, ST_SetGeoReference(rast, '10 0 0 -10 0.1 0.1', 'GDAL')
FROM source
UNION ALL
SELECT 2, ST_SetGeoReference(rast, '10 0 0 -10 5.1 -4.9', 'ESRI')
FROM source
UNION ALL
SELECT 3, ST_SetGeoReference(rast, 1, 1, 10, -10, 0.001, 0.001)
FROM source
)
SELECT
rid,
round(ST_UpperLeftX(rast)::numeric, 3) AS upperleftx,
round(ST_UpperLeftY(rast)::numeric, 3) AS upperlefty,
ST_ScaleX(rast) AS scalex,
ST_ScaleY(rast) AS scaley,
ST_SkewX(rast) AS skewx,
ST_SkewY(rast) AS skewy
FROM variants
ORDER BY rid;rid | upperleftx | upperlefty | scalex | scaley | skewx | skewy -----+------------+------------+--------+--------+-------+------- 0 | 0.000 | 0.000 | 1 | -1 | 0 | 0 1 | 0.100 | 0.100 | 10 | -10 | 0 | 0 2 | 0.100 | 0.100 | 10 | -10 | 0 | 0 3 | 1.000 | 1.000 | 10 | -10 | 0.001 | 0.001 (4 rows)
ST_GeoReference, ST_ScaleX, ST_ScaleY, ST_UpperLeftX, ST_UpperLeftY
ST_SetRotation — Ställ in rastrets rotation i radian.
raster ST_SetRotation(raster rast, float8 rotation);
Rotera rastret på ett enhetligt sätt. Rotationen anges i radianer. Se World File för mer information.
WITH variants AS (
SELECT rid, 'rotated' AS kind, ST_SetRotation(rast, 15) AS rast
FROM dummy_rast
UNION ALL
SELECT rid, 'original', rast
FROM dummy_rast
)
SELECT
rid,
kind,
round(ST_ScaleX(rast)::numeric, 4) AS scale_x,
round(ST_ScaleY(rast)::numeric, 4) AS scale_y,
round(ST_SkewX(rast)::numeric, 4) AS skew_x,
round(ST_SkewY(rast)::numeric, 4) AS skew_y
FROM variants
ORDER BY rid, kind;rid | kind | scale_x | scale_y | skew_x | skew_y -----+----------+---------+---------+--------+-------- 1 | original | 2.0000 | 3.0000 | 0.0000 | 0.0000 1 | rotated | -1.5194 | -2.2791 | 1.9509 | 1.3006 2 | original | 0.0500 | -0.0500 | 0.0000 | 0.0000 2 | rotated | -0.0380 | -0.0380 | 0.0325 | 0.0325 (4 rows)
ST_SetScale — Ställer in X- och Y-storleken för pixlar i enheter i koordinatreferenssystemet. Antal enheter/pixelbredd/höjd.
raster ST_SetScale(raster rast, float8 xy);
raster ST_SetScale(raster rast, float8 x, float8 y);
Ställer in X- och Y-storleken för pixlar i enheter i koordinatreferenssystemet. Antal enheter/pixelbredd/höjd. Om endast en enhet skickas in antas X och Y vara samma antal.
![]() | |
ST_SetScale skiljer sig från ST_Rescale genom att ST_SetScale inte gör om rastret för att matcha rastrets utsträckning. Den ändrar bara rastrets metadata (eller georeferens) för att korrigera en ursprungligen felaktigt specificerad skalning. ST_Rescale resulterar i ett raster med olika bredd och höjd som beräknats för att passa den geografiska omfattningen av indatarastret. ST_SetScale ändrar inte bredden eller höjden på rastret. |
Ändrad: 2.0.0 I WKTRaster-versioner kallades detta ST_SetPixelSize. Detta ändrades i 2.0.0.
UPDATE dummy_rast
SET rast = ST_SetScale(rast, 1.5)
WHERE rid = 2;
SELECT ST_ScaleX(rast) As pixx, ST_ScaleY(rast) As pixy, Box3D(rast) As newbox
FROM dummy_rast
WHERE rid = 2;pixx | pixy | newbox ------+------+---------------------------------------------- 1.5 | 1.5 | BOX(3427927.75 5793244 0, 3427935.25 5793251.5 0)
UPDATE dummy_rast
SET rast = ST_SetScale(rast, 1.5, 0.55)
WHERE rid = 2;
SELECT ST_ScaleX(rast) As pixx, ST_ScaleY(rast) As pixy, Box3D(rast) As newbox
FROM dummy_rast
WHERE rid = 2;pixx | pixy | newbox ------+------+-------------------------------------------- 1.5 | 0.55 | BOX(3427927.75 5793244 0,3427935.25 5793247 0)
ST_SetSkew — Ställer in georeferensens X- och Y-skevhet (eller rotationsparameter). Om endast en parameter anges, sätts X och Y till samma värde.
raster ST_SetSkew(raster rast, float8 skewxy);
raster ST_SetSkew(raster rast, float8 skewx, float8 skewy);
Ställer in georeferensens X- och Y-skevhet (eller rotationsparameter). Om endast en parameter skickas in, sätts X och Y till samma värde. Se World File för mer information.
This is the first example.
UPDATE dummy_rast SET rast = ST_SetSkew(rast, 1, 2) WHERE rid = 1;
SELECT
rid,
format('(%s, %s)', skewx, skewy) AS skew,
term,
georef[idx] AS value
FROM (
SELECT
rid,
ST_SkewX(rast) AS skewx,
ST_SkewY(rast) AS skewy,
string_to_array(ST_GeoReference(rast), E'\n') AS georef
FROM dummy_rast
WHERE rid = 1
) AS refs
CROSS JOIN (VALUES
(1, 'scaleX'),
(2, 'skewY'),
(3, 'skewX'),
(4, 'scaleY'),
(5, 'originX'),
(6, 'originY')
) AS parts(idx, term)
ORDER BY idx;rid | skew | term | value -----+--------+---------+-------------- 1 | (1, 2) | scaleX | 2.0000000000 1 | (1, 2) | skewY | 2.0000000000 1 | (1, 2) | skewX | 1.0000000000 1 | (1, 2) | scaleY | 3.0000000000 1 | (1, 2) | originX | 0.5000000000 1 | (1, 2) | originY | 0.5000000000 (6 rows)
This second example sets both values to the same number.
UPDATE dummy_rast SET rast = ST_SetSkew(rast, 0) WHERE rid = 1;
SELECT
rid,
format('(%s, %s)', skewx, skewy) AS skew,
term,
georef[idx] AS value
FROM (
SELECT
rid,
ST_SkewX(rast) AS skewx,
ST_SkewY(rast) AS skewy,
string_to_array(ST_GeoReference(rast), E'\n') AS georef
FROM dummy_rast
WHERE rid = 1
) AS refs
CROSS JOIN (VALUES
(1, 'scaleX'),
(2, 'skewY'),
(3, 'skewX'),
(4, 'scaleY'),
(5, 'originX'),
(6, 'originY')
) AS parts(idx, term)
ORDER BY idx;rid | skew | term | value -----+--------+---------+-------------- 1 | (0, 0) | scaleX | 2.0000000000 1 | (0, 0) | skewY | 0.0000000000 1 | (0, 0) | skewX | 0.0000000000 1 | (0, 0) | scaleY | 3.0000000000 1 | (0, 0) | originX | 0.5000000000 1 | (0, 0) | originY | 0.5000000000 (6 rows)
ST_SetSRID — Ställer in SRID för ett raster till ett visst heltal srid som definieras i tabellen spatial_ref_sys.
raster ST_SetSRID(raster rast, integer srid);
Ställer in SRID på ett raster till ett visst heltalsvärde.
![]() | |
Den här funktionen transformerar inte rastret på något sätt - den anger bara metadata som definierar den spatiala ref för det koordinatreferenssystem som det för närvarande befinner sig i. Användbart för transformationer senare. |
ST_SetUpperLeft — Ställer in värdet för det övre vänstra hörnet av pixeln i rastret till projicerade X- och Y-koordinater.
raster ST_SetUpperLeft(raster rast, double precision x, double precision y);
Ställ in värdet för det övre vänstra hörnet av rastret till de projicerade X- och Y-koordinaterna
SELECT ST_SetUpperLeft(rast, -71.01, 42.37)
FROM dummy_rast
WHERE rid = 2;
ST_Resample — Resampla ett raster med hjälp av en specificerad resamplingsalgoritm, nya dimensioner, ett godtyckligt rutnätshörn och en uppsättning rastergeoreferensattribut som definierats eller lånats från ett annat raster.
raster ST_Resample(raster rast, integer width, integer height, double precision gridx=NULL, double precision gridy=NULL, double precision skewx=0, double precision skewy=0, text algorithm=NearestNeighbor, double precision maxerr=0.125);
raster ST_Resample(raster rast, double precision scalex=0, double precision scaley=0, double precision gridx=NULL, double precision gridy=NULL, double precision skewx=0, double precision skewy=0, text algorithm=NearestNeighbor, double precision maxerr=0.125);
raster ST_Resample(raster rast, raster ref, text algorithm=NearestNeighbor, double precision maxerr=0.125, boolean usescale=true);
raster ST_Resample(raster rast, raster ref, boolean usescale, text algorithm=NearestNeighbor, double precision maxerr=0.125);
Resampla ett raster med en specificerad resamplingsalgoritm, nya dimensioner (bredd & höjd), ett rasterhörn (gridx & gridy) och en uppsättning rastergeoreferensattribut (scalex, scaley, skewx & skewy) definierade eller lånade från ett annat raster. Om man använder ett referensraster måste de två rastren ha samma SRID.
Nya pixelvärden beräknas med hjälp av någon av följande omsamplingsalgoritmer:
NearestNeighbor (engelsk eller amerikansk stavning)
Bilinjär
Kubisk
CubicSpline
Lanczos
Max
Min
Standardinställningen är NearestNeighbor, vilket är snabbast men ger den sämsta interpoleringen.
En maxerrorprocent på 0,125 används om ingen maxerr har angetts.
![]() | |
Hänvisa till: GDAL Warp resampling methods för mer information. |
Tillgänglighet: 2.0.0 Kräver GDAL 1.6.1+
Förbättrad: 3.4.0 max- och min-alternativ för omsampling har lagts till
SELECT
ST_Width(orig) AS orig_width,
ST_Width(reduce_100) AS new_width
FROM (
SELECT
rast AS orig,
ST_Resample(rast, 100, 100) AS reduce_100
FROM aerials.boston
WHERE ST_Intersects(
rast,
ST_Transform(ST_MakeEnvelope(-71.128, 42.2392, -71.1277, 42.2397, 4326),
26986)
)
LIMIT 1
) AS foo;orig_width | new_width
------------+-------------
200 | 100ST_Rescale — Resampla ett raster genom att endast justera dess skala (eller pixelstorlek). Nya pixelvärden beräknas med hjälp av omsamplingsalgoritmen NearestNeighbor (engelsk eller amerikansk stavning), Bilinear, Cubic, CubicSpline, Lanczos, Max eller Min. Standard är NearestNeighbor.
raster ST_Rescale(raster rast, double precision scalexy, text algorithm=NearestNeighbor, double precision maxerr=0.125);
raster ST_Rescale(raster rast, double precision scalex, double precision scaley, text algorithm=NearestNeighbor, double precision maxerr=0.125);
Omsampla ett raster genom att endast justera dess skala (eller pixelstorlek). Nya pixelvärden beräknas med hjälp av någon av följande omsamplingsalgoritmer:
NearestNeighbor (engelsk eller amerikansk stavning)
Bilinjär
Kubisk
CubicSpline
Lanczos
Max
Min
Standardinställningen är NearestNeighbor, vilket är snabbast men ger den sämsta interpoleringen.
scalex och scaley definierar den nya pixelstorleken. scaley måste ofta vara negativ för att få ett välorienterat raster.
När den nya scalex eller scaley inte är en divisor av rastrets bredd eller höjd, utökas det resulterande rastrets utsträckning så att det omfattar det tillhandahållna rastrets utsträckning. Om du vill vara säker på att behålla den exakta omfattningen av inmatningen, se ST_Resize
maxerr är tröskelvärdet för omsamplingsalgoritmens approximation av transformationen (i pixelenheter). Ett standardvärde på 0,125 används om maxerr inte anges, vilket är samma värde som används i GDAL:s verktyg gdalwarp. Om värdet sätts till noll sker ingen approximering.
![]() | |
Hänvisa till: GDAL Warp resampling methods för mer information. |
![]() | |
ST_Rescale skiljer sig från ST_SetScale genom att ST_SetScale inte omsamplar rastret för att matcha rastrets utsträckning. ST_SetScale ändrar endast rastrets metadata (eller georeferens) för att korrigera en ursprungligen felaktigt specificerad skalning. ST_Rescale resulterar i ett raster med olika bredd och höjd som beräknats för att passa den geografiska omfattningen av indatarastret. ST_SetScale ändrar inte bredden eller höjden på rastret. |
Tillgänglighet: 2.0.0 Kräver GDAL 1.6.1+
Förbättrad: 3.4.0 max- och min-alternativ för omsampling har lagts till
Ändrad: 2.1.0 Fungerar på raster utan SRID
Ett enkelt exempel är omskalning av ett raster från en pixelstorlek på 0,001 grader till en pixelstorlek på 0,0015 grader.
This example returns the original raster pixel size.
SELECT ST_PixelWidth(ST_AddBand(ST_MakeEmptyRaster(100, 100, 0, 0, 0.001, -0.001, 0, 0, 4269), '8BUI'::text, 1, 0)) width
0.001
This example returns the pixel size of the rescaled raster.
SELECT ST_PixelWidth(ST_Rescale(ST_AddBand(ST_MakeEmptyRaster(100, 100, 0, 0, 0.001, -0.001, 0, 0, 4269), '8BUI'::text, 1, 0), 0.0015)) width
0.0015
ST_Resize, ST_Resample, ST_SetScale, ST_ScaleX, ST_ScaleY, ST_Transform
ST_Reskew — Resampla ett raster genom att endast justera dess skevhet (eller rotationsparametrar). Nya pixelvärden beräknas med hjälp av algoritmen NearestNeighbor (engelsk eller amerikansk stavning), Bilinear, Cubic, CubicSpline eller Lanczos resampling. Standard är NearestNeighbor.
raster ST_Reskew(raster rast, double precision skewxy, text algorithm=NearestNeighbor, double precision maxerr=0.125);
raster ST_Reskew(raster rast, double precision skewx, double precision skewy, text algorithm=NearestNeighbor, double precision maxerr=0.125);
Resampla ett raster genom att endast justera dess skevhet (eller rotationsparametrar). Nya pixelvärden beräknas med omsamplingsalgoritmen NearestNeighbor (engelsk eller amerikansk stavning), Bilinear, Cubic, CubicSpline eller Lanczos. Standardinställningen är NearestNeighbor, som är snabbast men ger den sämsta interpoleringen.
skewx och skewy definierar den nya skew.
Utbredningen av det nya rastret kommer att omfatta utbredningen av det tillhandahållna rastret.
En maxerror-procent på 0,125 om ingen maxerr har angetts.
![]() | |
Hänvisa till: GDAL Warp resampling methods för mer information. |
![]() | |
ST_Reskew skiljer sig från ST_SetSkew på så sätt att ST_SetSkew inte omsamplar rastret för att matcha rastrets utsträckning. ST_SetSkew ändrar bara rastrets metadata (eller georeferens) för att korrigera en ursprungligen felaktigt angiven skevhet. ST_Reskew resulterar i ett raster med olika bredd och höjd som beräknats för att passa den geografiska utbredningen av indatarastret. ST_SetSkew ändrar inte bredden eller höjden på rastret. |
Tillgänglighet: 2.0.0 Kräver GDAL 1.6.1+
Ändrad: 2.1.0 Fungerar på raster utan SRID
Ett enkelt exempel på hur ett raster kan ändras från en skevhet på 0,0 till en skevhet på 0,0015.
This example uses the original non-rotated raster.
SELECT ST_Rotation(ST_AddBand(ST_MakeEmptyRaster(100, 100, 0, 0, 0.001, -0.001, 0, 0, 4269), '8BUI'::text, 1, 0));
st_rotation
-------------
0
(1 row)The reskewed raster rotation.
SELECT ST_Rotation(ST_Reskew(ST_AddBand(ST_MakeEmptyRaster(100, 100, 0, 0, 0.001, -0.001, 0, 0, 4269), '8BUI'::text, 1, 0), 0.0015));
st_rotation ------------------ -0.982793723247329 (1 row)
ST_Resample, ST_Rescale, ST_SetSkew, ST_SetRotation, ST_SkewX, ST_SkewY, ST_Transform
ST_SnapToGrid — Sampla om ett raster genom att fästa det i ett rutnät. Nya pixelvärden beräknas med hjälp av algoritmen NearestNeighbor (engelsk eller amerikansk stavning), Bilinear, Cubic, CubicSpline eller Lanczos resampling. Standard är NearestNeighbor.
raster ST_SnapToGrid(raster rast, double precision gridx, double precision gridy, text algorithm=NearestNeighbor, double precision maxerr=0.125, double precision scalex=DEFAULT 0, double precision scaley=DEFAULT 0);
raster ST_SnapToGrid(raster rast, double precision gridx, double precision gridy, double precision scalex, double precision scaley, text algorithm=NearestNeighbor, double precision maxerr=0.125);
raster ST_SnapToGrid(raster rast, double precision gridx, double precision gridy, double precision scalexy, text algorithm=NearestNeighbor, double precision maxerr=0.125);
Resample en raster genom att snappa den till ett rutnät som definieras av ett godtyckligt pixelhörn (gridx & gridy) och eventuellt en pixelstorlek (scalex & scaley). Nya pixelvärden beräknas med hjälp av omsamplingsalgoritmen NearestNeighbor (engelsk eller amerikansk stavning), Bilinear, Cubic, CubicSpline eller Lanczos. Standardinställningen är NearestNeighbor, som är snabbast men ger den sämsta interpoleringen.
gridx och gridy definierar ett godtyckligt pixelhörn i det nya rastret. Detta är inte nödvändigtvis det övre vänstra hörnet av det nya rastret och det behöver inte ligga inom eller på kanten av det nya rastrets utsträckning.
Du kan eventuellt definiera pixelstorleken för det nya rutnätet med scalex och scaley.
Utbredningen av det nya rastret kommer att omfatta utbredningen av det tillhandahållna rastret.
En maxerror-procent på 0,125 om ingen maxerr har angetts.
![]() | |
Hänvisa till: GDAL Warp resampling methods för mer information. |
![]() | |
Använd ST_Resample om du behöver mer kontroll över gridparametrarna. |
Tillgänglighet: 2.0.0 Kräver GDAL 1.6.1+
Ändrad: 2.1.0 Fungerar på raster utan SRID
Ett enkelt exempel på hur man snappar ett raster till ett något annorlunda rutnät.
This example returns the upper-left X coordinate of the original raster.
SELECT ST_UpperLeftX(ST_AddBand(ST_MakeEmptyRaster(10, 10, 0, 0, 0.001, -0.001, 0, 0, 4269), '8BUI'::text, 1, 0));
st_upperleftx
---------------
0
(1 row)The upper left of raster after snapping.
SELECT ST_UpperLeftX(ST_SnapToGrid(ST_AddBand(ST_MakeEmptyRaster(10, 10, 0, 0, 0.001, -0.001, 0, 0, 4269), '8BUI'::text, 1, 0), 0.0002, 0.0002));
st_upperleftx
---------------
-0.0008
(1 row)ST_Resize — Ändra storlek på ett raster till en ny bredd/höjd
raster ST_Resize(raster rast, integer width, integer height, text algorithm=NearestNeighbor, double precision maxerr=0.125);
raster ST_Resize(raster rast, double precision percentwidth, double precision percentheight, text algorithm=NearestNeighbor, double precision maxerr=0.125);
raster ST_Resize(raster rast, text width, text height, text algorithm=NearestNeighbor, double precision maxerr=0.125);
Ändra storlek på ett raster till en ny bredd/höjd. Den nya bredden/höjden kan anges i exakt antal pixlar eller som en procentandel av rastrets bredd/höjd. Omfattningen av det nya rastret kommer att vara densamma som omfattningen av det tillhandahållna rastret.
Nya pixelvärden beräknas med hjälp av omsamplingsalgoritmen NearestNeighbor (engelsk eller amerikansk stavning), Bilinear, Cubic, CubicSpline eller Lanczos. Standardinställningen är NearestNeighbor, som är snabbast men ger den sämsta interpoleringen.
Variant 1 förväntar sig den faktiska bredden/höjden på utdatarastret.
Variant 2 förväntar sig decimalvärden mellan noll (0) och ett (1) som anger procentandelen av inmatningsrastrets bredd/höjd.
Variant 3 tar antingen den faktiska bredden/höjden på utdatarastret eller en procentandel i textform ("20%") som anger procentandelen av inmatningsrastrets bredd/höjd.
Tillgänglighet: 2.1.0 Kräver GDAL 1.6.1+
WITH foo AS(
SELECT
1 AS rid,
ST_Resize(ST_AddBand(ST_MakeEmptyRaster(1000, 1000, 0, 0, 1, -1, 0, 0, 0),
1, '8BUI', 255, 0
),
'50%', '500') AS rast
UNION ALL
SELECT
2 AS rid,
ST_Resize(ST_AddBand(ST_MakeEmptyRaster(1000, 1000, 0, 0, 1, -1, 0, 0, 0),
1, '8BUI', 255, 0
),
500, 100) AS rast
UNION ALL
SELECT
3 AS rid,
ST_Resize(ST_AddBand(ST_MakeEmptyRaster(1000, 1000, 0, 0, 1, -1, 0, 0, 0),
1, '8BUI', 255, 0
),
0.25, 0.9) AS rast
)
SELECT
rid,
ST_Width(rast) AS width,
ST_Height(rast) AS height,
ST_ScaleX(rast) AS scale_x,
round(ST_ScaleY(rast)::numeric, 4) AS scale_y
FROM foo
ORDER BY ridrid | width | height | scale_x | scale_y -----+-------+--------+---------+--------- 1 | 500 | 500 | 2 | -2.0000 2 | 500 | 100 | 2 | -10.0000 3 | 250 | 900 | 4 | -1.1111 (3 rows)
ST_Transform — Återprojicerar ett raster i ett känt spatialt referenssystem till ett annat känt spatialt referenssystem med hjälp av en angiven omsamplingsalgoritm. Alternativen är NearestNeighbor, Bilinear, Cubic, CubicSpline, Lanczos med NearestNeighbor som standard.
raster ST_Transform(raster rast, integer srid, text algorithm=NearestNeighbor, double precision maxerr=0.125, double precision scalex, double precision scaley);
raster ST_Transform(raster rast, integer srid, double precision scalex, double precision scaley, text algorithm=NearestNeighbor, double precision maxerr=0.125);
raster ST_Transform(raster rast, raster alignto, text algorithm=NearestNeighbor, double precision maxerr=0.125);
Återprojicerar ett raster i ett känt spatialt referenssystem till ett annat känt spatialt referenssystem med hjälp av en angiven pixelwarpingalgoritm. Använder "NearestNeighbor" om ingen algoritm har angetts och maxerror procent på 0,125 om ingen maxerr har angetts.
Algoritmalternativen är: "NearestNeighbor", "Bilinear", "Cubic", "CubicSpline" och "Lanczos". Hänvisa till: GDAL Warp resampling methods för mer information.
ST_Transform förväxlas ofta med ST_SetSRID(). ST_Transform ändrar faktiskt koordinaterna för ett raster (och omsamplar pixelvärdena) från ett spatialt referenssystem till ett annat, medan ST_SetSRID() helt enkelt ändrar SRID-identifieraren för rastret.
Till skillnad från de andra varianterna kräver variant 3 ett referensraster som alignto. Det transformerade rastret kommer att transformeras till referensrastrets spatiala referenssystem (SRID) och anpassas (ST_SameAlignment = TRUE) till referensrastret.
![]() | |
If you find your transformation support is not working right, you may need to set the environment variable PROJSO to the projection library your PostGIS build is using. This just needs to have the name of the file. So for example on windows, you would in Control Panel -> System -> Environment Variables add a system variable called |
![]() | |
När du omvandlar en täckning av plattor vill du nästan alltid använda ett referensraster för att säkerställa samma inriktning och inga luckor i dina plattor, vilket visas i exemplet: Variant 3. |
Tillgänglighet: 2.0.0 Kräver GDAL 1.6.1+
Förbättrad: 2.1.0 Tillägg av ST_Transform(rast, alignto)-variant
Compare a source raster with nearest-neighbor and bilinear reprojections. The diagonal bands make the resampling behavior visible: nearest-neighbor keeps hard pixel steps, while bilinear smooths values between pixels. All three figures are generated from this query at manual build time.
WITH rows AS (
SELECT
y,
array_agg(
((
x * 3 + y * 5
+ CASE WHEN (x + y) % 8 < 4 THEN 80 ELSE 0 END
) % 255)::double precision
ORDER BY x
) AS row_values
FROM generate_series(1, 80) AS y
CROSS JOIN generate_series(1, 80) AS x
GROUP BY y
), source AS (
SELECT ST_SetValues(
ST_AddBand(
ST_MakeEmptyRaster(
80, 80,
-500000, 600000,
2500, -2500,
0, 0,
2163
),
1, '8BUI', 0, NULL
),
1, 1, 1,
array_agg(row_values ORDER BY y)::double precision[][]
) AS rast
FROM rows
), transformed AS (
SELECT
rast,
ST_Transform(rast, 4326, 'NearestNeighbor') AS nearest,
ST_Transform(rast, 4326, 'Bilinear') AS bilinear
FROM source
)
SELECT
ST_AsPNG(rast) AS "source (EPSG:2163)",
ST_AsPNG(nearest) AS "nearest (EPSG:4326)",
ST_AsPNG(bilinear) AS "bilinear (EPSG:4326)"
FROM transformed;PNG image, 80 x 80 pixels | PNG image, 98 x 64 pixels | PNG image, 98 x 64 pixels
Raster reprojection and resampling.
![]() Massachusetts State Plane source | ![]() WGS 84 nearest-neighbor | ![]() WGS 84 bilinear |
Variant 3.
Följande visar skillnaden mellan att använda ST_Transform(raster, srid) och ST_Transform(raster, alignto)
WITH foo AS (
SELECT 0 AS rid, ST_AddBand(ST_MakeEmptyRaster(2, 2, -500000, 600000, 100, -100, 0, 0, 2163), 1, '16BUI', 1, 0) AS rast UNION ALL
SELECT 1, ST_AddBand(ST_MakeEmptyRaster(2, 2, -499800, 600000, 100, -100, 0, 0, 2163), 1, '16BUI', 2, 0) AS rast UNION ALL
SELECT 2, ST_AddBand(ST_MakeEmptyRaster(2, 2, -499600, 600000, 100, -100, 0, 0, 2163), 1, '16BUI', 3, 0) AS rast UNION ALL
SELECT 3, ST_AddBand(ST_MakeEmptyRaster(2, 2, -500000, 599800, 100, -100, 0, 0, 2163), 1, '16BUI', 10, 0) AS rast UNION ALL
SELECT 4, ST_AddBand(ST_MakeEmptyRaster(2, 2, -499800, 599800, 100, -100, 0, 0, 2163), 1, '16BUI', 20, 0) AS rast UNION ALL
SELECT 5, ST_AddBand(ST_MakeEmptyRaster(2, 2, -499600, 599800, 100, -100, 0, 0, 2163), 1, '16BUI', 30, 0) AS rast UNION ALL
SELECT 6, ST_AddBand(ST_MakeEmptyRaster(2, 2, -500000, 599600, 100, -100, 0, 0, 2163), 1, '16BUI', 100, 0) AS rast UNION ALL
SELECT 7, ST_AddBand(ST_MakeEmptyRaster(2, 2, -499800, 599600, 100, -100, 0, 0, 2163), 1, '16BUI', 200, 0) AS rast UNION ALL
SELECT 8, ST_AddBand(ST_MakeEmptyRaster(2, 2, -499600, 599600, 100, -100, 0, 0, 2163), 1, '16BUI', 300, 0) AS rast
), bar AS (
SELECT
ST_Transform(rast, 4269) AS alignto
FROM foo
LIMIT 1
), baz AS (
SELECT
rid,
rast,
ST_Transform(rast, 4269) AS not_aligned,
ST_Transform(rast, alignto) AS aligned
FROM foo
CROSS JOIN bar
)
SELECT
ST_Collect(ST_ConvexHull(not_aligned) ORDER BY rid) AS not_aligned,
ST_Collect(ST_ConvexHull(aligned) ORDER BY rid) AS aligned
FROM bazMULTIPOLYGON(((-107.007 50.2,-107.005 50.2,-107.005 50.198,-107.007 50.198,-107.007 50.2)),((-107.004 50.201,-107.002 50.201,-107.002 50.198,-107.004 50.198,-107.004 50.201)),((-107.001 50.201,-106.999 50.201,-106.999 50.198,-107.001 50.198,-107.001 50.201)),((-107.007 50.199,-107.004 50.199,-107.004 50.196,-107.007 50.196,-107.007 50.199)),((-107.004 50.199,-107.001 50.199,-107.001 50.196,-107.004 50.196,-107.004 50.199)),((-107.001 50.199,-106.999 50.199,-106.999 50.196,-107.001 50.196,-107.001 50.199)),((-107.006 50.197,-107.004 50.197,-107.004 50.194,-107.006 50.194,-107.006 50.197)),((-107.004 50.197,-107.001 50.197,-107.001 50.194,-107.004 50.194,-107.004 50.197)),((-107.001 50.197,-106.998 50.197,-106.998 50.195,-107.001 50.195,-107.001 50.197))) | MULTIPOLYGON(((-107.007 50.2,-107.005 50.2,-107.005 50.198,-107.007 50.198,-107.007 50.2)),((-107.005 50.202,-107.001 50.202,-107.001 50.198,-107.005 50.198,-107.005 50.202)),((-107.002 50.202,-106.998 50.202,-106.998 50.198,-107.002 50.198,-107.002 50.202)),((-107.007 50.199,-107.003 50.199,-107.003 50.195,-107.007 50.195,-107.007 50.199)),((-107.005 50.199,-107.001 50.199,-107.001 50.195,-107.005 50.195,-107.005 50.199)),((-107.002 50.199,-106.998 50.199,-106.998 50.195,-107.002 50.195,-107.002 50.199)),((-107.007 50.198,-107.003 50.198,-107.003 50.194,-107.007 50.194,-107.007 50.198)),((-107.005 50.198,-107.001 50.198,-107.001 50.194,-107.005 50.194,-107.005 50.198)),((-107.002 50.198,-106.998 50.198,-106.998 50.194,-107.002 50.194,-107.002 50.198)))
ST_SetBandNoDataValue — Ställer in värdet för det angivna bandet som inte representerar några data. Band 1 förutsätts om inget band anges. För att markera ett band som att det inte har något nodata-värde, ställ in nodata-värdet = NULL.
raster ST_SetBandNoDataValue(raster rast, double precision nodatavalue);
raster ST_SetBandNoDataValue(raster rast, integer band, double precision nodatavalue, boolean forcechecking=false);
Ställer in det värde som representerar inga data för bandet. Band 1 antas om det inte specificeras. Detta påverkar resultaten från ST_Polygon, ST_DumpAsPolygons, och funktionerna ST_PixelAs...().
This example changes only the first band NODATA value.
UPDATE dummy_rast
SET rast = ST_SetBandNoDataValue(rast, 1, 254)
WHERE rid = 2;This example changes the NODATA value for bands 1, 2, and 3.
UPDATE dummy_rast
SET rast =
ST_SetBandNoDataValue(ST_SetBandNoDataValue(ST_SetBandNoDataValue(rast, 1, 254),
2, 99),
3, 108)
WHERE rid = 2;This example removes the NODATA value so that all pixels are considered by processing functions.
UPDATE dummy_rast
SET rast = ST_SetBandNoDataValue(rast, 1, NULL)
WHERE rid = 2;
ST_SetBandIsNoData — Ställer in bandets isnodata-flagga till TRUE.
raster ST_SetBandIsNoData(raster rast, integer band=1);
Ställer in isnodata-flaggan för bandet till true. Band 1 antas om det inte anges. Denna funktion bör endast anropas när flaggan anses vara smutsig. Det vill säga, när resultatet av anropet ST_BandIsNoData är annorlunda med TRUE som sista argument och utan att använda det
Tillgänglighet: 2.0.0
This example creates a dummy table with one raster column. The raster has two bands and one pixel per band. In the first band, the NODATA value and pixel value are both 3. In the second band, the NODATA value is 13 and the pixel value is 4.
create table dummy_rast (rid integer, rast raster);
insert into dummy_rast values(
1,
(
'01' -- little endian (uint8 ndr)
||
'0000' -- version (uint16 0)
||
'0200' -- nBands (uint16 0)
||
'17263529ED684A3F' -- scaleX (float64 0.000805965234044584)
||
'F9253529ED684ABF' -- scaleY (float64 -0.00080596523404458)
||
'1C9F33CE69E352C0' -- ipX (float64 -75.5533328537098)
||
'718F0E9A27A44840' -- ipY (float64 49.2824585505576)
||
'ED50EB853EC32B3F' -- skewX (float64 0.000211812383858707)
||
'7550EB853EC32B3F' -- skewY (float64 0.000211812383858704)
||
'E6100000' -- SRID (int32 4326)
||
'0100' -- width (uint16 1)
||
'0100' -- height (uint16 1)
||
'4' -- hasnodatavalue set to true, isnodata value set to false (when it should be true)
||
'2' -- first band type (4BUI)
||
'03' -- novalue==3
||
'03' -- pixel(0,0)==3 (same that nodata)
||
'0' -- hasnodatavalue set to false
||
'5' -- second band type (16BSI)
||
'0D00' -- novalue==13
||
'0400' -- pixel(0,0)==4
)::raster
);
select ST_BandIsNoData(rast, 1) from dummy_rast where rid = 1; -- Expected false
select ST_BandIsNoData(rast, 1, TRUE) from dummy_rast where rid = 1; -- Expected true
The isnodata flag is dirty, so set it to true.
update dummy_rast set rast = ST_SetBandIsNoData(rast, 1) where rid = 1;
select ST_BandIsNoData(rast, 1) from dummy_rast where rid = 1; -- Expected true
ST_SetBandPath — Uppdatera den externa sökvägen och bandnumret för ett out-db-band
raster ST_SetBandPath(raster rast, integer band, text outdbpath, integer outdbindex, boolean force=false);
Uppdaterar ett out-db-bands externa rasterfilsökväg och externa bandnummer.
![]() | |
Om |
Tillgänglighet: 2.5.0
WITH foo AS (
SELECT ST_AddBand(
NULL::raster,
'/home/pele/devel/geo/postgis-git/raster/test/regress/loader/Projected.tif',
NULL::int[]
) AS rast
)
SELECT
1 AS query,
bandnum,
regexp_replace(path, '^.*/', '') AS path,
outdbbandnum
FROM ST_BandMetaData(
(SELECT rast FROM foo),
ARRAY[1, 3, 2]::int[]
) AS metadata
UNION ALL
SELECT
2, bandnum,
regexp_replace(path, '^.*/', ''),
outdbbandnum
FROM ST_BandMetaData((
SELECT
ST_SetBandPath(rast,
2,
'/home/pele/devel/geo/postgis-git/raster/test/regress/loader/Projected2.tif',
1
) AS rast
FROM foo
),
ARRAY[1, 3, 2]::int[]
) AS metadata
ORDER BY 1, 2;In the second result set, band 2 now points at Projected2.tif and uses out-db band 1.
query | bandnum | path | outdbbandnum
-------+---------+----------------+--------------
1 | 1 | Projected.tif | 1
1 | 2 | Projected.tif | 2
1 | 3 | Projected.tif | 3
2 | 1 | Projected.tif | 1
2 | 2 | Projected2.tif | 1
2 | 3 | Projected.tif | 3ST_SetBandIndex — Uppdatera det externa bandnumret för ett out-db-band
raster ST_SetBandIndex(raster rast, integer band, integer outdbindex, boolean force=false);
Uppdaterar ett out-db-bands externa bandnummer. Detta påverkar inte den externa rasterfil som är associerad med out-db-bandet
![]() | |
Om |
![]() | |
Internt ersätter denna metod PostGIS-rastrets band vid indexbandet med ett nytt |
Tillgänglighet: 2.5.0
WITH foo AS (
SELECT ST_AddBand(
NULL::raster,
'/home/pele/devel/geo/postgis-git/raster/test/regress/loader/Projected.tif',
NULL::int[]
) AS rast
)
SELECT
1 AS query,
bandnum,
regexp_replace(path, '^.*/', '') AS path,
outdbbandnum
FROM ST_BandMetaData(
(SELECT rast FROM foo),
ARRAY[1, 3, 2]::int[]
) AS metadata
UNION ALL
SELECT
2, bandnum,
regexp_replace(path, '^.*/', ''),
outdbbandnum
FROM ST_BandMetaData((
SELECT
ST_SetBandIndex(rast,
2,
1
) AS rast
FROM foo
),
ARRAY[1, 3, 2]::int[]
) AS metadata
ORDER BY 1, 2;In the second result set, band 2 still points at the same file but now reads external band 1.
query | bandnum | path | outdbbandnum
-------+---------+---------------+--------------
1 | 1 | Projected.tif | 1
1 | 2 | Projected.tif | 2
1 | 3 | Projected.tif | 3
2 | 1 | Projected.tif | 1
2 | 2 | Projected.tif | 1
2 | 3 | Projected.tif | 3ST_Count — Returnerar antalet pixlar i ett givet band i ett raster eller en rastertäckning. Om inget band anges är standardvärdet band 1. Om exclude_nodata_value är satt till true räknas endast pixlar som inte är lika med nodatavärdet.
bigint ST_Count(raster rast, integer nband=1, boolean exclude_nodata_value=true);
bigint ST_Count(raster rast, boolean exclude_nodata_value);
Returnerar antalet pixlar i ett givet band i ett raster eller en rastertäckning. Om inget band anges är nband standardvärdet 1.
![]() | |
Om |
Ändrad: 3.1.0 - ST_Count(rastertable, rastercolumn, ...) varianterna borttagna. Använd ST_CountAgg istället.
Tillgänglighet: 2.0.0
Example will count all pixels not 249 and one will count all pixels.
SELECT rid, ST_Count(ST_SetBandNoDataValue(rast, 249)) As exclude_nodata,
ST_Count(ST_SetBandNoDataValue(rast, 249), false) As include_nodata
FROM dummy_rast WHERE rid=2;rid | exclude_nodata | include_nodata -----+----------------+---------------- 2 | 23 | 25
ST_CountAgg — Aggregera. Returnerar antalet pixlar i ett givet band i en uppsättning raster. Om inget band anges är standardvärdet band 1. Om exclude_nodata_value är satt till true räknas endast pixlar som inte är lika med NODATA-värdet.
bigint ST_CountAgg(raster rast, integer nband, boolean exclude_nodata_value, double precision sample_percent);
bigint ST_CountAgg(raster rast, integer nband, boolean exclude_nodata_value);
bigint ST_CountAgg(raster rast, boolean exclude_nodata_value);
Returnerar antalet pixlar i ett givet band i en uppsättning raster. Om inget band anges är nband standardvärdet 1.
Om exclude_nodata_value är satt till true räknas endast pixlar med ett värde som inte är lika med NODATA-värdet i rastret. Ställ in exclude_nodata_value till false för att räkna alla pixlar
Som standard samplas alla pixlar. För att få snabbare svar, ställ in sample_percent till ett värde mellan noll (0) och ett (1)
Tillgänglighet: 2.2.0
WITH foo AS (
SELECT
rast.rast
FROM (
SELECT ST_SetValue(ST_SetValue(ST_SetValue(ST_AddBand(ST_MakeEmptyRaster(10, 10, 10, 10, 2, 2, 0, 0, 0),
1, '64BF', 0, 0
),
1, 1, 1, -10
),
1, 5, 4, 0
),
1, 5, 5, 3.14159
) AS rast
) AS rast
FULL JOIN (
SELECT generate_series(1, 10) AS id
) AS id
ON 1 = 1
)
SELECT
ST_CountAgg(rast, 1, TRUE) AS non_nodata_pixels
FROM foo;non_nodata_pixels
-------------------
20
(1 row)ST_Histogram — Returnerar en uppsättning poster som sammanfattar en raster- eller rastertäckningsdatadistribution i separata bin-områden. Antalet bin beräknas automatiskt om det inte anges.
SETOF record ST_Histogram(raster rast, integer nband=1, boolean exclude_nodata_value=true, integer bins=autocomputed, double precision[] width=NULL, boolean right=false);
SETOF record ST_Histogram(raster rast, integer nband, integer bins, double precision[] width=NULL, boolean right=false);
SETOF record ST_Histogram(raster rast, integer nband, boolean exclude_nodata_value, integer bins, boolean right);
SETOF record ST_Histogram(raster rast, integer nband, integer bins, boolean right);
Returnerar en uppsättning poster bestående av min, max, count, procent för ett givet rasterband för varje bin. Om inget band anges är nband standardvärdet 1.
![]() | |
Som standard beaktas endast pixelvärden som inte är lika med |
widthwidth: en matris som anger bredden på varje kategori/behållare. Om antalet fack är större än antalet bredder upprepas bredderna.
Exempel: 9 fack med bredden [a, b, c] ger utdata som [a, b, c, a, b, c, a, b, c]
binsNumber of breakouts -- detta är antalet poster som du får tillbaka från funktionen om det anges. Om det inte anges beräknas antalet breakouts automatiskt.
rightberäkna histogrammet från höger i stället för från vänster (standard). Detta ändrar kriterierna för att utvärdera ett värde x från [a, b] till (a, b]
Ändrad: 3.1.0 Borttagen ST_Histogram(table_name, column_name)-variant.
Tillgänglighet: 2.0.0
Single raster tile - compute histograms for bands 1, 2, 3 and autocompute bins.
SELECT band, (stats).*
FROM (SELECT rid, band, ST_Histogram(rast, band) As stats
FROM dummy_rast CROSS JOIN generate_series(1, 3) As band
WHERE rid=2) As foo;band | min | max | count | percent
------+-------+-------+-------+---------
1 | 249 | 250 | 2 | 0.08
1 | 250 | 251 | 2 | 0.08
1 | 251 | 252 | 1 | 0.04
1 | 252 | 253 | 2 | 0.08
1 | 253 | 254 | 18 | 0.72
2 | 78 | 113.2 | 11 | 0.44
2 | 113.2 | 148.4 | 4 | 0.16
2 | 148.4 | 183.6 | 4 | 0.16
2 | 183.6 | 218.8 | 1 | 0.04
2 | 218.8 | 254 | 5 | 0.2
3 | 62 | 100.4 | 11 | 0.44
3 | 100.4 | 138.8 | 5 | 0.2
3 | 138.8 | 177.2 | 4 | 0.16
3 | 177.2 | 215.6 | 1 | 0.04
3 | 215.6 | 254 | 4 | 0.16Just band 2 but for 6 bins.
SELECT (stats).*
FROM (SELECT rid, ST_Histogram(rast, 2, 6) As stats
FROM dummy_rast
WHERE rid=2) As foo;min | max | count | percent
------------+------------+-------+---------
78 | 107.333333 | 9 | 0.36
107.333333 | 136.666667 | 6 | 0.24
136.666667 | 166 | 0 | 0
166 | 195.333333 | 4 | 0.16
195.333333 | 224.666667 | 1 | 0.04
224.666667 | 254 | 5 | 0.2
(6 rows)Same as previous but we explicitly control the pixel value range of each bin.
SELECT (stats).*
FROM (SELECT rid, ST_Histogram(rast, 2, 6, ARRAY[0.5, 1, 4, 100, 5]) As stats
FROM dummy_rast
WHERE rid=2) As foo;min | max | count | percent
-------+-------+-------+----------
78 | 78.5 | 1 | 0.08
78.5 | 79.5 | 1 | 0.04
79.5 | 83.5 | 0 | 0
83.5 | 183.5 | 17 | 0.0068
183.5 | 188.5 | 0 | 0
188.5 | 254 | 6 | 0.003664
(6 rows)ST_Quantile — Beräkna kvantiler för ett raster eller en rastertabells täckning i samband med urvalet eller populationen. Ett värde kan alltså undersökas för att ligga vid rastrets 25 %, 50 %, 75% percentil.
SETOF record ST_Quantile(raster rast, integer nband=1, boolean exclude_nodata_value=true, double precision[] quantiles=NULL);
SETOF record ST_Quantile(raster rast, double precision[] quantiles);
SETOF record ST_Quantile(raster rast, integer nband, double precision[] quantiles);
double precision ST_Quantile(raster rast, double precision quantile);
double precision ST_Quantile(raster rast, boolean exclude_nodata_value, double precision quantile=NULL);
double precision ST_Quantile(raster rast, integer nband, double precision quantile);
double precision ST_Quantile(raster rast, integer nband, boolean exclude_nodata_value, double precision quantile);
double precision ST_Quantile(raster rast, integer nband, double precision quantile);
Beräkna kvantiler för ett raster eller en rastertabells täckning i samband med urvalet eller populationen. Ett värde kan alltså undersökas för att ligga vid rastrets 25 %, 50 %, 75% percentil.
![]() | |
Om |
Ändrad: 3.1.0 Borttagen ST_Quantile(table_name, column_name)-variant.
Tillgänglighet: 2.0.0
Example will consider only pixels of band 1 that are not 249 and in named quantiles.
UPDATE dummy_rast SET rast = ST_SetBandNoDataValue(rast, 249) WHERE rid=2;
SELECT (pvq).*
FROM (SELECT ST_Quantile(rast, ARRAY[0.25, 0.75]) As pvq
FROM dummy_rast WHERE rid=2) As foo
ORDER BY (pvq).quantile;quantile | value
----------+-------
0.25 | 253
0.75 | 254SELECT ST_Quantile(rast, 0.75) As value FROM dummy_rast WHERE rid=2;
254
Real live example. Quantile of all pixels in band 2 intersecting a geometry.
SELECT rid, (ST_Quantile(rast, 2)).* As pvc
FROM o_4_boston
WHERE ST_Intersects(
rast,
ST_GeomFromText('POLYGON((224486 892151,224486 892200,224706 892200,224706 892151,224486 892151))', 26986)
)
ORDER BY value, quantile, rid
;rid | quantile | value -----+----------+------- 1 | 0 | 0 2 | 0 | 0 14 | 0 | 1 15 | 0 | 2 14 | 0.25 | 37 1 | 0.25 | 42 15 | 0.25 | 47 2 | 0.25 | 50 14 | 0.5 | 56 1 | 0.5 | 64 15 | 0.5 | 66 2 | 0.5 | 77 14 | 0.75 | 81 15 | 0.75 | 87 1 | 0.75 | 94 2 | 0.75 | 106 14 | 1 | 199 1 | 1 | 244 2 | 1 | 255 15 | 1 | 255
ST_SummaryStats — Returnerar summarystats bestående av count, sum, mean, stddev, min, max för ett givet rasterband i ett raster eller en rastertäckning. Band 1 antas om inget band anges.
summarystats ST_SummaryStats(raster rast, boolean exclude_nodata_value);
summarystats ST_SummaryStats(raster rast, integer nband, boolean exclude_nodata_value);
Returnerar summarystats bestående av count, sum, mean, stddev, min, max för ett givet rasterband i ett raster eller en rastertäckning. Om inget band anges är nband standardvärdet 1.
![]() | |
Som standard beaktas endast pixelvärden som inte är lika med |
![]() | |
Som standard samplas alla pixlar. För att få snabbare svar, ställ in |
Ändrad: 3.1.0 ST_SummaryStats(rastertable, rastercolumn, ...) varianterna har tagits bort. Använd ST_SummaryStatsAgg istället.
Tillgänglighet: 2.0.0
Single raster tile.
SELECT rid, band, (stats).*
FROM (SELECT rid, band, ST_SummaryStats(rast, band) As stats
FROM dummy_rast CROSS JOIN generate_series(1, 3) As band
WHERE rid=2) As foo;rid | band | count | sum | mean | stddev | min | max -----+------+-------+------+------------+-----------+-----+----- 2 | 1 | 23 | 5821 | 253.086957 | 1.248061 | 250 | 254 2 | 2 | 25 | 3682 | 147.28 | 59.862188 | 78 | 254 2 | 3 | 25 | 3290 | 131.6 | 61.647384 | 62 | 254
Summarize pixels that intersect buildings of interest.
This example selects the target buildings, clips band 2 of the raster tiles to each building boundary, computes statistics for each clipped region, and then summarizes those statistics by building. It took 574ms on PostGIS Windows 64-bit with all of Boston Buildings and aerial Tiles (tiles each 150x150 pixels ~ 134,000 tiles), ~102,000 building records.
WITH
-- our features of interest
feat AS (
SELECT gid AS building_id, geom_26986 AS geom
FROM buildings AS b
WHERE gid IN (100, 103, 150)
),
-- clip band 2 of raster tiles to boundaries of builds
-- then get stats for these clipped regions
b_stats AS (
SELECT building_id, (stats).*
FROM (
SELECT
building_id,
ST_SummaryStats(ST_Clip(rast, 2, geom)) AS stats
FROM aerials.boston
INNER JOIN feat
ON ST_Intersects(feat.geom, rast)
) AS foo
)
-- finally summarize stats
SELECT
building_id,
SUM(count) AS num_pixels,
MIN(min) AS min_pval,
MAX(max) AS max_pval,
SUM(mean * count) / SUM(count) AS avg_pval
FROM b_stats
WHERE count
> 0
GROUP BY building_id
ORDER BY building_id;building_id | num_pixels | min_pval | max_pval | avg_pval
-------------+------------+----------+----------+------------------
100 | 1090 | 1 | 255 | 61.0697247706422
103 | 655 | 7 | 182 | 70.5038167938931
150 | 895 | 2 | 252 | 185.642458100559
Raster coverage.
This example returns statistics for each band.
SELECT band, (stats).*
FROM (SELECT band, ST_SummaryStats('o_4_boston', 'rast', band) As stats
FROM generate_series(1, 3) As band) As foo;band | count | sum | mean | stddev | min | max
------+---------+--------+------------------+------------------+-----+-----
1 | 8450000 | 725799 | 82.7064349112426 | 45.6800222638537 | 0 | 255
2 | 8450000 | 700487 | 81.4197705325444 | 44.2161184161765 | 0 | 255
3 | 8450000 | 575943 | 74.682739408284 | 44.2143885481407 | 0 | 255For a table, sampling less than 100% can improve speed. Here the sampling is set to 25%.
SELECT band, (stats).*
FROM (SELECT band, ST_SummaryStats('o_4_boston', 'rast', band, true, 0.25) As stats
FROM generate_series(1, 3) As band) As foo;band | count | sum | mean | stddev | min | max
------+---------+--------+------------------+------------------+-----+-----
1 | 2112500 | 180686 | 82.6890480473373 | 45.6961043857248 | 0 | 255
2 | 2112500 | 174571 | 81.448503668639 | 44.2252623171821 | 0 | 255
3 | 2112500 | 144364 | 74.6765884023669 | 44.2014869384578 | 0 | 255
ST_SummaryStatsAgg — Aggregera. Returnerar summarystats bestående av count, sum, mean, stddev, min, max för ett givet rasterband i en uppsättning raster. Band 1 antas om inget band anges.
summarystats ST_SummaryStatsAgg(raster rast, integer nband, boolean exclude_nodata_value, double precision sample_percent);
summarystats ST_SummaryStatsAgg(raster rast, boolean exclude_nodata_value, double precision sample_percent);
summarystats ST_SummaryStatsAgg(raster rast, integer nband, boolean exclude_nodata_value);
Returnerar summarystats bestående av count, sum, mean, stddev, min, max för ett givet rasterband i ett raster eller en rastertäckning. Om inget band anges är nband standardvärdet 1.
![]() | |
Som standard beaktas endast pixelvärden som inte är lika med |
![]() | |
Som standard samplas alla pixlar. För att få snabbare svar, ställ in |
Tillgänglighet: 2.2.0
WITH foo AS (
SELECT
rast.rast
FROM (
SELECT ST_SetValue(ST_SetValue(ST_SetValue(ST_AddBand(ST_MakeEmptyRaster(10, 10, 10, 10, 2, 2, 0, 0, 0),
1, '64BF', 0, 0
),
1, 1, 1, -10
),
1, 5, 4, 0
),
1, 5, 5, 3.14159
) AS rast
) AS rast
FULL JOIN (
SELECT generate_series(1, 10) AS id
) AS id
ON 1 = 1
)
SELECT
(stats).count AS count,
round((stats).sum::numeric, 3) AS sum,
round((stats).mean::numeric, 3) AS mean,
round((stats).stddev::numeric, 3) AS stddev,
round((stats).min::numeric, 3) AS min,
round((stats).max::numeric, 3) AS max
FROM (
SELECT
ST_SummaryStatsAgg(rast, 1, TRUE, 1) AS stats
FROM foo
) bar;count | sum | mean | stddev | min | max
-------+---------+--------+--------+---------+-------
20 | -68.584 | -3.429 | 6.571 | -10.000 | 3.142
(1 row)ST_ValueCount — Returnerar en uppsättning poster som innehåller ett pixelbandvärde och en räkning av antalet pixlar i ett givet band i ett raster (eller en rastertäckning) som har en given uppsättning värden. Om inget band anges är standardvärdet band 1. Som standard räknas inte pixlar med nodatavärden. och alla andra värden i pixeln matas ut och pixelbandvärden avrundas till närmaste heltal.
SETOF record ST_ValueCount(raster rast, integer nband=1, boolean exclude_nodata_value=true, double precision[] searchvalues=NULL, double precision roundto=0, double precision OUT value, integer OUT count);
SETOF record ST_ValueCount(raster rast, integer nband, double precision[] searchvalues, double precision roundto=0, double precision OUT value, integer OUT count);
SETOF record ST_ValueCount(raster rast, double precision[] searchvalues, double precision roundto=0, double precision OUT value, integer OUT count);
bigint ST_ValueCount(raster rast, double precision searchvalue, double precision roundto=0);
bigint ST_ValueCount(raster rast, integer nband, boolean exclude_nodata_value, double precision searchvalue, double precision roundto=0);
bigint ST_ValueCount(raster rast, integer nband, double precision searchvalue, double precision roundto=0);
SETOF record ST_ValueCount(text rastertable, text rastercolumn, integer nband=1, boolean exclude_nodata_value=true, double precision[] searchvalues=NULL, double precision roundto=0, double precision OUT value, integer OUT count);
SETOF record ST_ValueCount(text rastertable, text rastercolumn, double precision[] searchvalues, double precision roundto=0, double precision OUT value, integer OUT count);
SETOF record ST_ValueCount(text rastertable, text rastercolumn, integer nband, double precision[] searchvalues, double precision roundto=0, double precision OUT value, integer OUT count);
bigintST_ValueCount(text rastertable, text rastercolumn, integer nband, boolean exclude_nodata_value, double precision searchvalue, double precision roundto=0);
bigint ST_ValueCount(text rastertable, text rastercolumn, double precision searchvalue, double precision roundto=0);
bigint ST_ValueCount(text rastertable, text rastercolumn, integer nband, double precision searchvalue, double precision roundto=0);
Returnerar en uppsättning poster med kolumnerna value count som innehåller pixelbandvärdet och antalet pixlar i rasterplattan eller rastertäckningen för det valda bandet.
Om inget band anges är nband standardvärdet 1. Om inga searchvalues anges returneras alla pixelvärden som finns i rastret eller rastertäckningen. Om ett sökvärde anges, returneras ett heltal i stället för poster som anger antalet pixlar som har det pixelbandvärdet
![]() | |
Om |
Tillgänglighet: 2.0.0
Example will count only pixels of band 1 that are not 249.
UPDATE dummy_rast SET rast = ST_SetBandNoDataValue(rast, 249) WHERE rid=2;
SELECT (pvc).*
FROM (SELECT ST_ValueCount(rast) As pvc
FROM dummy_rast WHERE rid=2) As foo
ORDER BY (pvc).value;value | count -------+------- 250 | 2 251 | 1 252 | 2 253 | 6 254 | 12
Example will coount all pixels of band 1 including 249.
SELECT (pvc).*
FROM (SELECT ST_ValueCount(rast, 1, false) As pvc
FROM dummy_rast WHERE rid=2) As foo
ORDER BY (pvc).value;value | count -------+------- 249 | 2 250 | 2 251 | 1 252 | 2 253 | 6 254 | 12
Example will count only non-nodata value pixels of band 2.
SELECT (pvc).*
FROM (SELECT ST_ValueCount(rast, 2) As pvc
FROM dummy_rast WHERE rid=2) As foo
ORDER BY (pvc).value;value | count
-------+-------
78 | 1
79 | 1
88 | 1
89 | 1
96 | 1
97 | 1
98 | 1
99 | 2
112 | 2
:
Real live example. Count all the pixels in an aerial raster tile band 2 intersecting a geometry. And return only the pixel band values that have a count > 500.
SELECT (pvc).value, SUM((pvc).count) As total
FROM (SELECT ST_ValueCount(rast, 2) As pvc
FROM o_4_boston
WHERE ST_Intersects(
rast,
ST_GeomFromText('POLYGON((224486 892151,224486 892200,224706 892200,224706 892151,224486 892151))', 26986)
)
) As foo
GROUP BY (pvc).value
HAVING SUM((pvc).count) > 500
ORDER BY (pvc).value;value | total
-------+-----
51 | 502
54 | 521Just return count of pixels in each raster tile that have value of 100 of tiles that intersect a specific geometry.
SELECT rid, ST_ValueCount(rast, 2, 100) As count
FROM o_4_boston
WHERE ST_Intersects(
rast,
ST_GeomFromText('POLYGON((224486 892151,224486 892200,224706 892200,224706 892151,224486 892151))', 26986)
) ;rid | count -----+------- 1 | 56 2 | 95 14 | 37 15 | 64
ST_RastFromWKB — Returnera ett rastervärde från ett Well-Known Binary (WKB)-raster.
raster ST_RastFromWKB(bytea wkb);
Givet ett Well-Known Binary (WKB) raster, returnera ett raster.
Tillgänglighet: 2.5.0
SELECT (ST_MetaData(ST_RastFromWKB('\001\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\010@\000\000\000\000\000\000\340?\000\000\000\000\000\000\340?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\000\000\000\012\000\024\000'::bytea
)
)).* AS metadata;upperleftx | upperlefty | width | height | scalex | scaley | skewx | skewy | srid | numbands
------------+------------+-------+--------+--------+--------+-------+-------+------+----------
0.5 | 0.5 | 10 | 20 | 2 | 3 | 0 | 0 | 10 | 0ST_RastFromHexWKB — Returnera ett rastervärde från en Hex-representation av Well-Known Binary (WKB)-raster.
raster ST_RastFromHexWKB(text wkb);
Givet ett Well-Known Binary (WKB)-raster i Hex-representation, returnera ett raster.
Tillgänglighet: 2.5.0
SELECT (ST_MetaData(ST_RastFromHexWKB('010000000000000000000000400000000000000840000000000000E03F000000000000E03F000000000000000000000000000000000A0000000A001400'
)
)).* AS metadata;upperleftx | upperlefty | width | height | scalex | scaley | skewx | skewy | srid | numbands
------------+------------+-------+--------+--------+--------+-------+-------+------+----------
0.5 | 0.5 | 10 | 20 | 2 | 3 | 0 | 0 | 10 | 0ST_AsBinary/ST_AsWKB — Returnerar WKB-representationen (Well-Known Binary) av rastret.
bytea ST_AsBinary(raster rast, boolean outasin=FALSE);
bytea ST_AsWKB(raster rast, boolean outasin=FALSE);
Returnerar den binära representationen av rastret. Om outasin är TRUE behandlas out-db-band som in-db. Se raster/doc/RFC2-WellKnownBinaryFormat som finns i PostGIS källmapp för detaljer om representationen.
Detta är användbart i binära markörer för att hämta data från databasen utan att konvertera dem till en strängrepresentation.
![]() | |
Som standard innehåller WKB-utdata den externa filsökvägen för out-db-band. Om klienten inte har tillgång till rasterfilen som ligger till grund för ett out-db-band, ska |
Förbättrad: 2.1.0 Tillägg av outasin
Förbättrad: 2.5.0 Tillägg av ST_AsWKB
SELECT ST_AsBinary(rast) AS rastbin FROM dummy_rast WHERE rid=1;
\001\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\010@\000\000\000\000\000\000\340?\000\000\000\000\000\000\340?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\000\000\000\012\000\024\000
ST_AsHexWKB — Returnerar Well-Known Binary (WKB) i Hex-representation av rastret.
bytea ST_AsHexWKB(raster rast, boolean outasin=FALSE);
Returnerar den binära representationen i Hex-representationen av rastret. Om outasin är TRUE behandlas out-db-band som in-db. Se raster/doc/RFC2-WellKnownBinaryFormat som finns i PostGIS källmapp för detaljer om representationen.
![]() | |
Som standard innehåller Hex WKB-utdata den externa filsökvägen för out-db-band. Om klienten inte har tillgång till den rasterfil som ligger till grund för ett out-db-band, ska |
Tillgänglighet: 2.5.0
SELECT ST_AsHexWKB(rast) AS rastbin FROM dummy_rast WHERE rid=1;
010000000000000000000000400000000000000840000000000000E03F000000000000E03F000000000000000000000000000000000A0000000A001400
ST_AsGDALRaster — Returnerar rasterplattan i det angivna GDAL Raster-formatet. Rasterformat är ett av de format som stöds av ditt kompilerade bibliotek. Använd ST_GDALDrivers() för att få en lista över de format som stöds av ditt bibliotek.
bytea ST_AsGDALRaster(raster rast, text format, text[] options=NULL, integer srid=sameassource);
Returnerar rasterplattan i det angivna formatet. Argumenten specificeras nedan:
format som ska matas ut. Detta är beroende av de drivrutiner som kompileras i ditt libgdal-bibliotek. Generellt tillgängliga är 'JPEG', 'GTIff', 'PNG'. Använd ST_GDALDrivers för att få en lista över format som stöds av ditt bibliotek.
options textuppsättning av GDAL-alternativ. Giltiga alternativ är beroende av formatet. Se alternativ för GDAL Rasterformat för mer information.
srid the spatial reference identifier to embed in the output raster
Tillgänglighet: 2.0.0 - kräver GDAL >= 1.6.0.
Export multiple raster tiles as a single JPEG image with 50 percent quality.
SELECT ST_AsGDALRaster(ST_Union(rast), 'JPEG', ARRAY['QUALITY=50']) As rastjpg FROM dummy_rast WHERE rast && ST_MakeEnvelope(10, 10, 11, 11);
One way to export raster into another format is using PostgreSQL large object export functions. The following repeats the JPEG example and exports the result. Note that this requires superuser access because it uses server-side large object functions. It will also export to path on server network. If you need export locally, use the psql equivalent lo_ functions which export to the local file system instead of the server file system.
DROP TABLE IF EXISTS tmp_out ;
CREATE TABLE tmp_out AS
SELECT lo_from_bytea(
0,
ST_AsGDALRaster(ST_Union(rast), 'JPEG', ARRAY['QUALITY=50'])
) AS loid
FROM dummy_rast
WHERE rast && ST_MakeEnvelope(10, 10, 11, 11);
SELECT lo_export(loid, '/tmp/dummy.jpg')
FROM tmp_out;
SELECT lo_unlink(loid)
FROM tmp_out;
Export a raster as a GeoTIFF using the default creation options.
SELECT ST_AsGDALRaster(rast, 'GTiff') AS rasttiff FROM dummy_rast WHERE rid = 2;
Export a GeoTIFF using JPEG compression at 90 percent quality and embed SRID 4269.
SELECT ST_AsGDALRaster(
rast,
'GTiff',
ARRAY['COMPRESS=JPEG', 'JPEG_QUALITY=90'],
4269) AS rasttiff
FROM dummy_rast WHERE rid = 2;
ST_AsJPEG — Returnerar de valda banden i rasterplattan som en enda JPEG-bild (byte-array) (Joint Photographic Exports Group). Om inget band anges och 1 eller fler än 3 band, används endast det första bandet. Om endast 3 band anges används alla 3 banden och mappas till RGB.
bytea ST_AsJPEG(raster rast, text[] options=NULL);
bytea ST_AsJPEG(raster rast, integer nband, integer quality);
bytea ST_AsJPEG(raster rast, integer nband, text[] options=NULL);
bytea ST_AsJPEG(raster rast, integer[] nbands, text[] options=NULL);
bytea ST_AsJPEG(raster rast, integer[] nbands, integer quality);
Returnerar de valda banden i rastret som en enda JPEG-bild (Joint Photographic Exports Group Image). Använd ST_AsGDALRaster om du behöver exportera som mindre vanliga rastertyper. Om inget band anges och 1 eller fler än 3 band, används endast det första bandet. Om 3 band används alla 3 banden. Det finns många varianter av funktionen med många alternativ. Dessa specificeras nedan:
nband är för export av enstaka band.
nbands är en array av band som ska exporteras (notera att max är 3 för JPEG) och ordningen på banden är RGB. t.ex. ARRAY[3,2,1] innebär att band 3 mappas till rött, band 2 till grönt och band 1 till blått
kvalitetssiffra från 0 till 100. Ju högre siffra desto skarpare blir bilden.
options text Mängd GDAL-alternativ enligt definitionen för JPEG (se create_options för JPEG ST_GDALDrivers). För JPEG är giltiga alternativ PROGRESSIVE ON eller OFF och QUALITY ett intervall från 0 till 100 och standardvärdet är 75. Se GDAL Rasterformatalternativ för mer information.
Tillgänglighet: 2.0.0 - kräver GDAL >= 1.6.0.
Output the first three bands at 75 percent quality.
SELECT ST_AsJPEG(rast) As rastjpg FROM dummy_rast WHERE rid=2;
Output only the first band at 90 percent quality.
SELECT ST_AsJPEG(rast, 1, 90) As rastjpg FROM dummy_rast WHERE rid=2;
Output the first three bands, mapping band 2 to red, band 1 to green, and band 3 to blue, using progressive encoding at 90 percent quality.
SELECT ST_AsJPEG(rast, ARRAY[2, 1, 3], ARRAY['QUALITY=90', 'PROGRESSIVE=ON']) As rastjpg FROM dummy_rast WHERE rid=2;
ST_AsPNG — Returnerar de valda banden i rasterkaklet som en enda PNG-bild (portable network graphics) (byte-array). Om 1, 3 eller 4 band i rastret och inga band anges, används alla band. Om fler än 2 eller fler än 4 band och inga band anges, används endast band 1. Banden mappas till RGB- eller RGBA-rymd.
bytea ST_AsPNG(raster rast, text[] options=NULL);
bytea ST_AsPNG(raster rast, integer nband, integer compression);
bytea ST_AsPNG(raster rast, integer nband, text[] options=NULL);
bytea ST_AsPNG(raster rast, integer[] nbands, integer compression);
bytea ST_AsPNG(raster rast, integer[] nbands, text[] options=NULL);
Returnerar de valda banden i rastret som en enda PNG-bild (Portable Network Graphics Image). Använd ST_AsGDALRaster om du behöver exportera som mindre vanliga rastertyper. Om inget band anges exporteras de 3 första banden. Det finns många varianter av funktionen med många alternativ. Om ingen srid anges används rastrets srid. Dessa specificeras nedan:
nband är för export av enstaka band.
nbands är en array av band som ska exporteras (notera att max är 4 för PNG) och ordningen på banden är RGBA. t.ex. ARRAY[3,2,1] betyder att band 3 mappas till rött, band 2 till grönt och band 1 till blått
kompressionsnummer från 1 till 9. Ju högre siffra desto större kompression.
options text Array av GDAL-alternativ enligt definitionen för PNG (se create_options for PNG på ST_GDALDrivers). För PNG är endast ZLEVEL giltigt (den tid som ska läggas på komprimering - standard 6), t.ex. ARRAY['ZLEVEL=9']. WORLDFILE är inte tillåtet eftersom funktionen skulle behöva mata ut två utdata. Se GDAL Rasterformatalternativ för mer information.
Tillgänglighet: 2.0.0 - kräver GDAL >= 1.6.0.
Export the first 3 bands and map band 3 to red, band 1 to green, and band 2 to blue.
SELECT ST_AsPNG(rast) As rastpng
FROM dummy_rast WHERE rid=2;
SELECT ST_AsPNG(rast, ARRAY[3, 1, 2]) As rastpng
FROM dummy_rast WHERE rid=2;
ST_AsTIFF — Returnerar de band som valts i rastret som en enda TIFF-bild (byte-array). Om inget band anges eller om något av de angivna banden inte finns i rastret, försöker alla band användas.
bytea ST_AsTIFF(raster rast, text[] options='', integer srid=sameassource);
bytea ST_AsTIFF(raster rast, text compression='', integer srid=sameassource);
bytea ST_AsTIFF(raster rast, integer[] nbands, text compression='', integer srid=sameassource);
bytea ST_AsTIFF(raster rast, integer[] nbands, text[] options, integer srid=sameassource);
Returnerar de valda banden i rastret som ett enda TIFF-format (Tagged Image File Format). Om inget band anges försöker alla band användas. Detta är ett omslag runt ST_AsGDALRaster. Använd ST_AsGDALRaster om du behöver exportera som mindre vanliga rastertyper. Det finns många varianter av funktionen med många alternativ. Om det inte finns någon SRS-text för spatial referens används rastrets spatiala referens. Dessa specificeras nedan:
nbands är en array av band som ska exporteras (notera att max är 3 för PNG) och ordningen på banden är RGB. t.ex. ARRAY[3,2,1] innebär att band 3 mappas till rött, band 2 till grönt och band 1 till blått
komprimering Kompressionsuttryck -- JPEG90 (eller någon annan procent), LZW, JPEG, DEFLATE9.
options text Array av GDAL-skaparalternativ enligt definitionen för GTiff (se create_options for GTiff på ST_GDALDrivers). eller se GDAL Raster format options för mer information.
srid srid av spatial_ref_sys för rastret. Detta används för att fylla i georeferensinformationen
Tillgänglighet: 2.0.0 - kräver GDAL >= 1.6.0.
SELECT ST_AsTIFF(rast, 'JPEG90') As rasttiff
FROM dummy_rast WHERE rid=2;
crop inte anges eller om TRUE anges, beskärs utdatarastret. Om touched är inställt på TRUE inkluderas pixlar som berörs, annars inkluderas endast pixlar vars mittpunkt ligger i geometrin.ST_Clip — Returnerar det raster som klippts av indatageometrin. Om bandnummer inte anges bearbetas alla band. Om crop inte anges eller om TRUE anges, beskärs utdatarastret. Om touched är inställt på TRUE inkluderas pixlar som berörs, annars inkluderas endast pixlar vars mittpunkt ligger i geometrin.
raster ST_Clip(raster rast, integer[] nband, geometry geom, double precision[] nodataval=NULL, boolean crop=TRUE, boolean touched=FALSE);
raster ST_Clip(raster rast, integer nband, geometry geom, double precision nodataval, boolean crop=TRUE, boolean touched=FALSE);
raster ST_Clip(raster rast, integer nband, geometry geom, boolean crop, boolean touched=FALSE);
raster ST_Clip(raster rast, geometry geom, double precision[] nodataval=NULL, boolean crop=TRUE, boolean touched=FALSE);
raster ST_Clip(raster rast, geometry geom, double precision nodataval, boolean crop=TRUE, boolean touched=FALSE);
raster ST_Clip(raster rast, geometry geom, boolean crop, boolean touched=FALSE);
Returnerar ett raster som är klippt av indatageometrin geom. Om bandindex inte anges bearbetas alla band.
Raster som blir resultatet av ST_Clip måste ha ett nodatavärde tilldelat för områden som klippts, ett för varje band. Om inget anges och indatarastret inte har något nodatavärde definierat, sätts nodatavärdena för det resulterande rastret till ST_MinPossibleValue(ST_BandPixelType(rast, band)). När antalet nodatavärden i matrisen är mindre än antalet band används det sista i matrisen för de återstående banden. Om antalet nodatavärden är större än antalet band ignoreras de extra nodatavärdena. Alla varianter som accepterar en matris med noddatavärden accepterar också ett enda värde som tilldelas varje band.
Om crop inte anges antas true, vilket innebär att utdatarastret beskärs till skärningspunkten mellan geom- och rast-utbredningarna. Om crop är satt till false får det nya rastret samma utsträckning som rast. Om touched är satt till true väljs alla pixlar i rast som skär geometrin.
![]() | |
Standardinställningen är touched=false, vilket innebär att endast pixlar vars mittpunkt täcks av geometrin väljs. |
Förbättrad: 3.5.0 - rörda argument har lagts till.
Tillgänglighet: 2.0.0
Förbättrad: 2.1.0 Omskriven i C
I exemplen här används flygdata från Massachusetts som finns tillgängliga på MassGIS webbplats MassGIS Aerial Orthos.
Comparing selecting all touched vs. not all touched.
WITH source AS (
SELECT rast, geom
FROM ST_AsRaster(ST_Letters('R'), scalex =
> 1.0, scaley =
> -1.0) AS r(rast)
INNER JOIN ST_GeomFromText('LINESTRING(0 1,5 6,10 10)') AS g(geom)
ON ST_Intersects(r.rast, g.geom)
), clipped AS (
SELECT rast,
ST_Clip(rast, geom, touched =
> true) AS rast_touched,
ST_Clip(rast, geom, touched =
> false) AS rast_not_touched
FROM source
), variants AS (
SELECT 'original' AS title, ST_Count(rast) AS pixel_count, rast AS rendered
FROM clipped
UNION ALL
SELECT 'all touched', ST_Count(rast_touched), rast_touched
FROM clipped
UNION ALL
SELECT 'default clip', ST_Count(rast_not_touched), rast_not_touched
FROM clipped
)
SELECT title, pixel_count, ST_AsPNG(rendered) AS image
FROM variants
ORDER BY CASE title
WHEN 'original' THEN 1
WHEN 'all touched' THEN 2
ELSE 3
END;title | pixel_count | image --------------+-------------+---------------------------- original | 2605 | PNG image, 48 x 74 pixels all touched | 16 | PNG image, 11 x 11 pixels default clip | 10 | PNG image, 11 x 11 pixels (3 rows)
The following self-contained example uses three simple shapes as RGB bands. It compares cropping band 1, clipping band 1 without cropping and then restoring bands 2 and 3, and clipping every band without cropping.
WITH canvas AS (
SELECT ST_AddBand(
ST_AddBand(
ST_AddBand(
ST_MakeEmptyRaster(128, 128, 0, 128, 1, -1, 0, 0, 0),
'8BUI'::text, 0::double precision, 0::double precision
),
'8BUI'::text, 0::double precision, 0::double precision
),
'8BUI'::text, 0::double precision, 0::double precision
) AS rast
), source AS (
SELECT ST_SetValue(
ST_SetValue(
ST_SetValue(rast, 1, ST_Buffer('POINT(32 96)'::geometry, 22), 220),
2, ST_Buffer('LINESTRING(18 20,110 110)'::geometry, 6,
'endcap=flat join=bevel'), 210
),
3, ST_Buffer('LINESTRING(10 48,118 48)'::geometry, 7,
'endcap=flat'), 180
) AS rast,
ST_Buffer('POINT(64 64)'::geometry, 34) AS clipper
FROM canvas
), variants AS (
SELECT 'original RGB' AS title, rast AS rendered FROM source
UNION ALL
SELECT 'band 1 cropped', ST_Clip(rast, 1, clipper, true) FROM source
UNION ALL
SELECT
'band 1 only',
ST_AddBand(
ST_Clip(rast, 1, clipper, false),
ARRAY[ST_Band(rast, 2), ST_Band(rast, 3)]
)
FROM source
UNION ALL
SELECT 'all bands clipped', ST_Clip(rast, clipper, false) FROM source
)
SELECT title, ST_AsPNG(rendered) AS image
FROM variants
ORDER BY CASE title
WHEN 'original RGB' THEN 1
WHEN 'band 1 cropped' THEN 2
WHEN 'band 1 only' THEN 3
ELSE 4
END;title | image -------------------+----------------------------- original RGB | PNG image, 128 x 128 pixels band 1 cropped | PNG image, 68 x 68 pixels band 1 only | PNG image, 128 x 128 pixels all bands clipped | PNG image, 128 x 128 pixels (4 rows)
Crop, single-band clipping, and all-band clipping.
![]() Source tile | ![]() Cropped |
![]() One-band source | ![]() One-band clip |
![]() All-band source | ![]() All-band clip |
ST_ColorMap — Skapar ett nytt raster med upp till fyra 8BUI-band (gråskala, RGB, RGBA) från källrastret och ett angivet band. Band 1 antas om det inte specificeras.
raster ST_ColorMap(raster rast, integer nband=1, text colormap=grayscale, text method=INTERPOLATE);
raster ST_ColorMap(raster rast, text colormap, text method=INTERPOLATE);
Tillämpa en färgkarta på bandet vid nband i rast, vilket resulterar i ett nytt raster som består av upp till fyra 8BUI-band. Antalet 8BUI-band i det nya rastret bestäms av antalet färgkomponenter som definieras i colormap.
Om nband inte anges antas band 1.
colormap kan vara ett nyckelord för en fördefinierad colormap eller en uppsättning linjer som definierar värdet och färgkomponenterna.
Giltigt fördefinierat nyckelord för färgkartor:
gråskala eller gråskala för ett 8BUI-bandraster av nyanser av grått.
pseudofärg för ett raster med fyra 8BUI (RGBA)-band med färger från blått till grönt till rött.
brand för ett raster med fyra 8BUI (RGBA)-band med färger från svart till rött till ljusgult.
bluered för ett raster med fyra 8BUI (RGBA)-band med färger från blått till ljusvitt till rött.
Användare kan skicka en uppsättning poster (en per rad) till colormap för att ange anpassade färgkartor. Varje post består i allmänhet av fem värden: pixelvärdet och motsvarande röd-, grön-, blå- och alfakomponenter (färgkomponenter mellan 0 och 255). Procentvärden kan användas i stället för pixelvärden, där 0% aoch 100% aär de lägsta och högsta värdena i rasterbandet. Värdena kan separeras med kommatecken (','), tabbar, kolon (':') och/eller mellanslag. Pixelvärdet kan sättas till nv, null eller nodata för NODATA-värdet. Ett exempel ges nedan.
5 0 0 0 255
4 100:50 55 255
1 150, 100 150 255
0% 255 255 255 255
nv 0 0 0 0
Syntaxen för colormap liknar den för färgreliefläget i GDAL gdaldem.
Giltiga nyckelord för metod:
INTERPOLATE för att använda linjär interpolation för att mjukt blanda färgerna mellan de angivna pixelvärdena
EXACT för att strikt matcha endast de pixelvärden som finns i färgkartan. Pixlar vars värde inte matchar en post i färgkartan kommer att sättas till 0 0 0 0 0 (RGBA)
NEAREST för att använda den färgkartspost vars värde ligger närmast pixelvärdet
![]() | |
En bra referens för färgkartor är ColorBrewer. |
![]() | |
De resulterande banden av nytt raster kommer inte att ha något NODATA-värde inställt. Använd ST_SetBandNoDataValue för att ställa in ett NODATA-värde om ett sådant behövs. |
Tillgänglighet: 2.1.0
This example builds a raster from rotated buffered lines and compares the original values with predefined and custom color maps.
WITH ref AS (
SELECT ST_MakeEmptyRaster(200, 200, 0, 200, 1, -1, 0, 0) AS rast
), source AS (
SELECT ST_Union(rast) AS rast
FROM (
SELECT
ST_AsRaster(ST_Rotate(ST_Buffer('LINESTRING(0 2,50 50,150 150,125 50)'::geometry,
i*2
),
pi() * i * 0.125, ST_Point(50, 50)
),
ref.rast, '8BUI'::text, i * 5
) AS rast
FROM ref
CROSS JOIN generate_series(1, 10, 3) AS i
) AS shapes
)
SELECT title, ST_AsPNG(rendered) AS image
FROM source
CROSS JOIN LATERAL (VALUES
('original', rast),
('grayscale', ST_ColorMap(rast, 1, 'greyscale')),
('pseudocolor', ST_ColorMap(rast, 1, 'pseudocolor')),
('fire', ST_ColorMap(rast, 1, 'fire')),
('blue-red', ST_ColorMap(rast, 1, 'bluered')),
('custom red', ST_ColorMap(
rast,
1,
E'100% 255 0 0 255\n80% 160 0 0 255\n50% 130 0 0 255\n' ||
E'30% 30 0 0 255\n20% 60 0 0 255\n0% 0 0 0 255\n' ||
E'nv 255 255 255 0'
))
) AS variants(title, rendered);title | image
------------+--------------------------------
original | PNG image, 224 x 295 pixels
grayscale | PNG image, 224 x 295 pixels
pseudocolor| PNG image, 224 x 295 pixels
fire | PNG image, 224 x 295 pixels
blue-red | PNG image, 224 x 295 pixels
custom red | PNG image, 224 x 295 pixels
ST_Grayscale — Skapar ett nytt bandraster med ett 8BUI-band från källrastret och angivna band som representerar rött, grönt och blått
(1) raster ST_Grayscale(raster rast, integer redband=1, integer greenband=2, integer blueband=3, text extenttype=INTERSECTION);
(2) raster ST_Grayscale(rastbandarg[] rastbandargset, text extenttype=INTERSECTION);
Skapa ett raster med ett 8BUI-band givet tre indataband (från ett eller flera raster). Alla indataband vars pixeltyp inte är 8BUI kommer att omklassificeras med hjälp av ST_Reclass.
![]() | |
Den här funktionen är inte som ST_ColorMap med nyckelordet |
Tillgänglighet: 2.5.0
This self-contained example paints an apple with gradients and highlights into three raster bands. It compares the original RGB raster with the equivalent grayscale results produced by both function variants.
WITH pixels AS (
SELECT
col,
row,
x,
y,
(((x - 48.0)^2 / (25.0^2) + (y - 54.0)^2 / (29.0^2) < 1)
OR ((x - 72.0)^2 / (25.0^2) + (y - 54.0)^2 / (29.0^2) < 1))
AND NOT ((x - 60.0)^2 / (8.0^2) + (y - 26.0)^2 / (5.0^2) < 1) AS fruit,
((x - 82.0) * 0.84 + (y - 28.0) * 0.54)^2 / (22.0^2)
+ (-(x - 82.0) * 0.54 + (y - 28.0) * 0.84)^2 / (8.0^2) < 1 AS leaf,
abs((x - 62.0) * 0.96 - (y - 29.0) * 0.28) < 3
AND x BETWEEN 60 AND 69 AND y BETWEEN 21 AND 45 AS stem
FROM (
SELECT
col,
row,
col / 2.0 AS x,
row / 2.0 AS y
FROM generate_series(1, 180) AS row
CROSS JOIN generate_series(1, 240) AS col
) AS source_pixels
), shaded AS (
SELECT
col,
row,
x,
y,
CASE
WHEN stem THEN 95 + y * 0.7 + (x % 3) * 8
WHEN leaf THEN 28 + (90 - x) * 0.5
WHEN fruit THEN LEAST(255, GREATEST(0,
150
+ (85 - sqrt((x - 39.0)^2 + (y - 37.0)^2)) * 1.1
+ CASE
WHEN (x - 43.0)^2 / (10.0^2) + (y - 43.0)^2 / (7.0^2) < 1
THEN 35
ELSE 0
END
- CASE
WHEN (x - 77.0)^2 / (20.0^2) + (y - 67.0)^2 / (13.0^2) < 1
THEN 35
ELSE 0
END
+ ((x * 13 + y * 7) % 19 - 9)
))
ELSE 245
END AS red,
CASE
WHEN stem THEN 50 + y * 0.35
WHEN leaf THEN LEAST(190, GREATEST(40,
105 + (95 - x) * 1.2 + (y - 20) * 1.5
+ CASE
WHEN (x - 76.0)^2 / (12.0^2) + (y - 24.0)^2 / (4.0^2) < 1
THEN 45
ELSE 0
END
))
WHEN fruit THEN LEAST(95, GREATEST(15,
24 + (68 - y) * 0.35
+ CASE
WHEN (x - 43.0)^2 / (10.0^2) + (y - 43.0)^2 / (7.0^2) < 1
THEN 30
ELSE 0
END
+ ((x * 5 + y * 11) % 13 - 6)
))
ELSE 245
END AS green,
CASE
WHEN stem THEN 22 + (x % 4) * 3
WHEN leaf THEN 42 + (100 - x) * 0.4
WHEN fruit THEN LEAST(75, GREATEST(10,
18
+ CASE
WHEN (x - 43.0)^2 / (10.0^2) + (y - 43.0)^2 / (7.0^2) < 1
THEN 25
ELSE 0
END
+ ((x * 3 + y * 5) % 11 - 5)
))
ELSE 245
END AS blue
FROM pixels
), rows AS (
SELECT
row,
array_agg(red::double precision ORDER BY col) AS red_values,
array_agg(green::double precision ORDER BY col) AS green_values,
array_agg(blue::double precision ORDER BY col) AS blue_values
FROM shaded
GROUP BY row
), source AS (
SELECT ST_SetValues(ST_SetValues(ST_SetValues(
ST_AddBand(ST_AddBand(ST_AddBand(
ST_MakeEmptyRaster(240, 180, 0, 180, 1, -1, 0, 0, 0),
'8BUI'::text, 245::double precision, 0::double precision),
'8BUI'::text, 245::double precision, 0::double precision),
'8BUI'::text, 245::double precision, 0::double precision),
1, 1, 1, array_agg(red_values ORDER BY row)::double precision[][]),
2, 1, 1, array_agg(green_values ORDER BY row)::double precision[][]),
3, 1, 1, array_agg(blue_values ORDER BY row)::double precision[][]) AS rast
FROM rows
)
SELECT ST_AsPNG(rast) AS "original RGB",
ST_AsPNG(ST_Grayscale(rast)) AS "grayscale (variant 1)",
ST_AsPNG(ST_Grayscale(ARRAY[
ROW(rast, 1)::rastbandarg,
ROW(rast, 2)::rastbandarg,
ROW(rast, 3)::rastbandarg
]::rastbandarg[])) AS "grayscale (variant 2)"
FROM source;original RGB | grayscale (variant 1) | grayscale (variant 2) -----------------------------+----------------------------+---------------------------- PNG image, 240 x 180 pixels | PNG image, 240 x 180 pixels | PNG image, 240 x 180 pixels (1 row)
Original photographic illustration:
![]() original apple | ![]() grayscale apple |
ST_Intersection — Returnerar ett raster eller en uppsättning geometri-pixelvärdespar som representerar den delade delen av två raster eller den geometriska skärningspunkten mellan en vektorisering av rastret och en geometri.
setof geomval ST_Intersection(geometry geom, raster rast, integer band_num=1);
setof geomval ST_Intersection(raster rast, geometry geom);
setof geomval ST_Intersection(raster rast, integer band, geometry geomin);
raster ST_Intersection(raster rast1, raster rast2, double precision[] nodataval);
raster ST_Intersection(raster rast1, raster rast2, text returnband, double precision[] nodataval);
raster ST_Intersection(raster rast1, integer band1, raster rast2, integer band2, double precision[] nodataval);
raster ST_Intersection(raster rast1, integer band1, raster rast2, integer band2, text returnband, double precision[] nodataval);
Returnerar ett raster eller en uppsättning geometri-pixelvärdespar som representerar den delade delen av två raster eller den geometriska skärningspunkten mellan en vektorisering av rastret och en geometri.
De tre första varianterna, som returnerar en uppsättning geomval, fungerar i vektorrymd. Rastret vektoriseras först (med hjälp av ST_DumpAsPolygons) till en uppsättning geomval-rader och dessa rader korsas sedan med geometrin med hjälp av PostGIS-funktionen ST_Intersection (geometry, geometry). Geometrier som endast skär ett noddatavärdesområde i ett raster returnerar en tom geometri. De utesluts normalt från resultaten genom korrekt användning av ST_Intersects i WHERE-satsen.
Du kan komma åt geometri- och värdedelarna i den resulterande uppsättningen geomval genom att omge dem med parenteser och lägga till '.geom' eller '.val' i slutet av uttrycket. t.ex. (ST_Intersection(rast, geom)).geom
De andra varianterna, som returnerar ett raster, fungerar i rasterutrymme. De använder två raster-versionen av ST_MapAlgebraExpr för att utföra korsningen.
Det resulterande rastrets utsträckning motsvarar den geometriska skärningspunkten mellan de två rasterutsträckningarna. Det resulterande rastret innehåller "BAND1", "BAND2" eller "BOTH" band, enligt vad som skickas som returbandparameter. Nodatavärdesområden som finns i något band resulterar i nodatavärdesområden i alla band i resultatet. Med andra ord blir varje pixel som korsas av en nodatavärdespixel en nodatavärdespixel i resultatet.
Raster som blir resultatet av ST_Intersection måste ha ett nodatavärde tilldelat för områden som inte korsar varandra. Du kan definiera eller ersätta nodata-värdet för alla resulterande band genom att tillhandahålla en nodataval[] -array med ett eller två nodata-värden beroende på om du begär "BAND1"-, "BAND2"- eller "BÅDA"-band. Det första värdet i matrisen ersätter nodatavärdet i det första bandet och det andra värdet ersätter nodatavärdet i det andra bandet. Om ett inmatningsband inte har något nodatavärde definierat och inga sådana tillhandahålls som en matris, väljs ett med hjälp av funktionen ST_MinPossibleValue. Alla varianter som accepterar en matris av nodatavärden kan också acceptera ett enda värde som kommer att tilldelas varje efterfrågat band.
I alla varianter, om inget bandnummer anges, antas band 1. Om du behöver en skärningspunkt mellan ett raster och en geometri som returnerar ett raster, se ST_Clip.
![]() | |
For more control over the result extent or NODATA handling, use the two-raster variant of ST_MapAlgebraExpr. To compute a raster-space intersection with a geometry, use ST_Clip. Use this function together with ST_Intersects and an index on the raster or geometry column when filtering table data. |
Förbättrad: 2.0.0 - Intersektion i rasterrymden infördes. I tidigare versioner före 2.0.0 stöddes endast intersektion som utfördes i vektorrymd.
SELECT
foo.rid,
foo.gid,
GeometryType((foo.geomval).geom) AS geom_type,
(foo.geomval).val AS value
FROM (
SELECT
A.rid,
g.gid,
ST_Intersection(A.rast, g.geom) As geomval
FROM dummy_rast AS A
CROSS JOIN (
VALUES
(1, ST_Point(3427928, 5793243.85) ),
(2, 'LINESTRING(3427927.85 5793243.75,3427927.8 5793243.75,3427927.8 5793243.8)'::geometry),
(3, 'LINESTRING(1 2,3 4)'::geometry)
) As g(gid, geom)
WHERE A.rid = 2
) AS foo;rid | gid | geom_type | value -----+-----+----------------------+------- 2 | 1 | POINT | 249 2 | 1 | POINT | 253 2 | 2 | POINT | 254 2 | 2 | POINT | 251 2 | 2 | POINT | 253 2 | 2 | LINESTRING | 252 2 | 2 | MULTILINESTRING | 250 2 | 3 | GEOMETRYCOLLECTION |
The same line example rendered in a common coordinate frame. The raster footprint and complete input line remain visible behind the returned intersection pieces.
WITH source AS (
SELECT
rast,
ST_GeomFromText(
'LINESTRING(3427927.85 5793243.75,'
'3427927.8 5793243.75,3427927.8 5793243.8)'
) AS input_geometry
FROM dummy_rast
WHERE rid = 2
), intersection AS (
SELECT
rast,
input_geometry,
ST_Collect(gv.geom) AS result_geometry
FROM source
CROSS JOIN LATERAL ST_Intersection(rast, input_geometry) AS gv
GROUP BY rast, input_geometry
), layers AS (
SELECT
'raster' AS title,
ST_Translate(ST_Envelope(rast), -3427927.75, -5793243.75) AS geom
FROM intersection
UNION ALL
SELECT
'input',
ST_Translate(input_geometry, -3427927.75, -5793243.75)
FROM intersection
UNION ALL
SELECT
'intersection',
ST_Translate(result_geometry, -3427927.75, -5793243.75)
FROM intersection
)
SELECT title, geom AS geom
FROM layers
ORDER BY CASE title
WHEN 'raster' THEN 1
WHEN 'input' THEN 2
ELSE 3
END;title | geom --------------+------------------------------------------------------------- raster | POLYGON((0 0,0 0.25,0.25 0.25,0.25 0,0 0)) input | LINESTRING(0.1 0,0.05 0,0.05 0.05) intersection | GEOMETRYCOLLECTION
geomval, ST_Intersects, ST_MapAlgebraExpr, ST_Clip, ST_AsText
ST_MapAlgebra (callback function version) — Callback function version - Returnerar ett enbandsraster med ett eller flera indataraster, bandindex och en användarspecificerad callback-funktion.
raster ST_MapAlgebra(rastbandarg[] rastbandargset, regprocedure callbackfunc, text pixeltype=NULL, text extenttype=INTERSECTION, raster customextent=NULL, integer distancex=0, integer distancey=0, text[] VARIADIC userargs=NULL);
raster ST_MapAlgebra(raster rast, integer[] nband, regprocedure callbackfunc, text pixeltype=NULL, text extenttype=FIRST, raster customextent=NULL, integer distancex=0, integer distancey=0, text[] VARIADIC userargs=NULL);
raster ST_MapAlgebra(raster rast, integer nband, regprocedure callbackfunc, text pixeltype=NULL, text extenttype=FIRST, raster customextent=NULL, integer distancex=0, integer distancey=0, text[] VARIADIC userargs=NULL);
raster ST_MapAlgebra(raster rast1, integer nband1, raster rast2, integer nband2, regprocedure callbackfunc, text pixeltype=NULL, text extenttype=INTERSECTION, raster customextent=NULL, integer distancex=0, integer distancey=0, text[] VARIADIC userargs=NULL);
raster ST_MapAlgebra(raster rast, integer nband, regprocedure callbackfunc, float8[] mask, boolean weighted, text pixeltype=NULL, text extenttype=INTERSECTION, raster customextent=NULL, text[] VARIADIC userargs=NULL);
Returnerar ett enbandsraster med ett eller flera indataraster, bandindex och en användarspecificerad återkallningsfunktion.
rast,rast1,rast2, rastbandargsetRaster på vilka kartalgebraprocessen utvärderas.
rastbandargset gör det möjligt att använda en map algebra-operation på många raster och/eller många band. Se exempel Variant 1.
nband, nband1, nband2Bandnummer för det raster som ska utvärderas. nband kan vara ett heltal eller ett heltal[] som anger banden. nband1 är band på rast1 och nband2 är band på rast2 för fallet 2 raster/2 band.
callbackfuncParametern callbackfunc måste vara namnet och signaturen för en SQL- eller PL/pgSQL-funktion, som kastas till en regprocedure. Ett exempel på PL/pgSQL-funktionsexempel är:
CREATE OR REPLACE FUNCTION sample_callbackfunc(value double precision[][][], pos integer[][], VARIADIC userargs text[])
RETURNS double precision
AS $$
BEGIN
RETURN 0;
END;
$$ LANGUAGE 'plpgsql' IMMUTABLE;
The callbackfunc must have two or three arguments: a 3-dimension double precision array, a 2-dimension integer array and, optionally, a variadic 1-dimension text array. The first argument value is the set of values (as double precision) from all input rasters. The three dimensions (where indexes are 1-based) are: raster #, row y, column x. The second argument position is the set of pixel positions from the output raster and input rasters. The outer dimension (where indexes are 0-based) is the raster #. The position at outer dimension index 0 is the output raster's pixel position. For each outer dimension, there are two elements in the inner dimension for X and Y. The optional third argument userargs is for passing through any user-specified arguments.
The callback return value is used as the value of the output pixel. If the callback returns NULL, the output pixel is set to NODATA when the output band has a NODATA value. If the output band has no NODATA value, a NULL callback result raises an error.
För att skicka ett regprocedure-argument till en SQL-funktion krävs att hela funktionssignaturen skickas och sedan kastas till en regprocedure-typ. För att skicka ovanstående exempel på PL / pgSQL-funktion som ett argument är SQL för argumentet:
'sample_callbackfunc(double precision[], integer[], text[])'::regprocedure
Note that PostgreSQL array types do not encode dimensions in function signatures, so multidimensional callback arguments are written as double precision[] and integer[] in the regprocedure signature.
maskEn n-dimensionell array (matris) med tal som används för att filtrera vilka celler som skickas till map algebra call-back-funktionen. 0 betyder att ett granncellsvärde ska behandlas som ingen data och 1 betyder att värdet ska behandlas som data. Om weight är satt till true används värdena som multiplikatorer för att multiplicera pixelvärdet för det värdet i grannskapspositionen.
weightedboolean (true/false) för att ange om ett maskvärde ska viktas (multipliceras med originalvärdet) eller inte (gäller endast proto som tar en mask).
pixeltypeOm pixeltype skickas in kommer det ena bandet i det nya rastret att ha den pixeltypen. Om pixeltype anges som NULL eller utelämnas kommer det nya rasterbandet att ha samma pixeltype som det angivna bandet i det första rastret (för omfattningstyper: INTERSECTION, UNION, FIRST, CUSTOM) eller det angivna bandet i det lämpliga rastret (för omfattningstyper: SECOND, LAST). Om du är osäker, ange alltid pixeltype.
Den resulterande pixeltypen för utdatarastret måste vara en som listas i ST_BandPixelType eller utelämnas eller sättas till NULL.
extenttypeMöjliga värden är INTERSECTION (standard), UNION, FIRST (standard för en rastervariant), SECOND (andra), LAST (sista), CUSTOM (anpassad).
customextentOm extentype är CUSTOM måste ett raster tillhandahållas för customextent. Se exempel 4 i Variant 1.
distancexAvståndet i pixlar från referenscellen i x-riktningen. Bredden på den resulterande matrisen skulle alltså vara 2*avståndx + 1. Om inget anges beaktas endast referenscellen (grannskap 0).
distanceyAvståndet i pixlar från referenscellen i y-riktningen. Höjden på den resulterande matrisen blir 2*avståndety + 1. Om inget anges beaktas endast referenscellen (grannskapet 0).
userargsIf the callbackfunc declares a third argument, that argument is a variadic text array. All trailing text arguments are passed through to the specified callbackfunc, and are contained in the userargs argument.
![]() | |
För mer information om VARIADIC-nyckelordet, se PostgreSQL-dokumentationen och avsnittet "SQL-funktioner med variabelt antal argument" i Query Language (SQL) -funktioner. |
Variant 1 accepterar en array av rastbandarg som gör det möjligt att använda en map algebra-operation på många raster och/eller många band. Se exempel Variant 1.
Varianterna 2 och 3 arbetar med ett eller flera band i ett raster. Se exempel Variant 2 och 3.
Variant 4 arbetar med två raster med ett band per raster. Se exempel Variant 4.
Tillgänglighet: 2.2.0: Möjlighet att lägga till en mask
Tillgänglighet: 2.1.0
Compare an unmasked mean with neighbor-only and weighted-neighbor masks. The weighted mask multiplies neighboring values by 2 before computing the result.
WITH foo AS (
SELECT ST_SetBandNoDataValue(
ST_SetValue(
ST_SetValue(
ST_AsRaster(
ST_Buffer('LINESTRING(50 50,100 90,100 50)'::geometry, 5, 'join=bevel'),
200, 200, ARRAY['8BUI'], ARRAY[100], ARRAY[0]
),
ST_Buffer('POINT(70 70)'::geometry, 10, 'quad_segs=1'),
50
),
'LINESTRING(20 20,100 100,150 98)'::geometry,
1
),
0
) AS rast
), variants AS (
SELECT 'original' AS title, rast
FROM foo
UNION ALL
SELECT 'unmasked mean' AS title,
ST_MapAlgebra(rast, 1, 'ST_Mean4ma(double precision[], int[], text[])'::regprocedure) AS rast
FROM foo
UNION ALL
SELECT 'neighbor-only mean' AS title,
ST_MapAlgebra(
rast,
1,
'ST_Mean4ma(double precision[], int[], text[])'::regprocedure,
'{{1,1,1}, {1,0,1}, {1,1,1}}'::double precision[],
false
) AS rast
FROM foo
UNION ALL
SELECT 'weighted neighbor mean' AS title,
ST_MapAlgebra(
rast,
1,
'ST_Mean4ma(double precision[], int[], text[])'::regprocedure,
'{{2,2,2}, {2,0,2}, {2,2,2}}'::double precision[],
true
) AS rast
FROM foo
)
SELECT title, ST_AsPNG(rast) AS image
FROM variants;title | image
------------------------+--------------------------------
original | PNG image, 200 x 200 pixels
unmasked mean | PNG image, 200 x 200 pixels
neighbor-only mean | PNG image, 200 x 200 pixels
weighted neighbor mean | PNG image, 200 x 200 pixels
Variant 1.
Ett raster, ett band
WITH foo AS (
SELECT 1 AS rid, ST_AddBand(ST_MakeEmptyRaster(2, 2, 0, 0, 1, -1, 0, 0, 0), 1, '16BUI', 1, 0) AS rast
)
SELECT
ST_MapAlgebra(ARRAY[ROW(rast, 1)]::rastbandarg[],
'sample_callbackfunc(double precision[], int[], text[])'::regprocedure
) AS rast
FROM foo
Ett raster, flera band
WITH foo AS (
SELECT 1 AS rid, ST_AddBand(ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(2, 2, 0, 0, 1, -1, 0, 0, 0), 1, '16BUI', 1, 0), 2, '8BUI', 10, 0), 3, '32BUI', 100, 0) AS rast
)
SELECT
ST_MapAlgebra(ARRAY[ROW(rast, 3), ROW(rast, 1), ROW(rast, 3), ROW(rast, 2)]::rastbandarg[],
'sample_callbackfunc(double precision[], int[], text[])'::regprocedure
) AS rast
FROM foo
Flera raster, flera band
WITH foo AS (
SELECT 1 AS rid, ST_AddBand(ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(2, 2, 0, 0, 1, -1, 0, 0, 0), 1, '16BUI', 1, 0), 2, '8BUI', 10, 0), 3, '32BUI', 100, 0) AS rast UNION ALL
SELECT 2 AS rid, ST_AddBand(ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(2, 2, 0, 1, 1, -1, 0, 0, 0), 1, '16BUI', 2, 0), 2, '8BUI', 20, 0), 3, '32BUI', 300, 0) AS rast
)
SELECT
ST_MapAlgebra(ARRAY[ROW(t1.rast, 3), ROW(t2.rast, 1), ROW(t2.rast, 3), ROW(t1.rast, 2)]::rastbandarg[],
'sample_callbackfunc(double precision[], int[], text[])'::regprocedure
) AS rast
FROM foo t1
CROSS JOIN foo t2
WHERE t1.rid = 1
AND t2.rid = 2
Complete example of tiles of a coverage with neighborhood.
WITH foo AS (
SELECT 0 AS rid, ST_AddBand(ST_MakeEmptyRaster(2, 2, 0, 0, 1, -1, 0, 0, 0), 1, '16BUI', 1, 0) AS rast UNION ALL
SELECT 1, ST_AddBand(ST_MakeEmptyRaster(2, 2, 2, 0, 1, -1, 0, 0, 0), 1, '16BUI', 2, 0) AS rast UNION ALL
SELECT 2, ST_AddBand(ST_MakeEmptyRaster(2, 2, 4, 0, 1, -1, 0, 0, 0), 1, '16BUI', 3, 0) AS rast UNION ALL
SELECT 3, ST_AddBand(ST_MakeEmptyRaster(2, 2, 0, -2, 1, -1, 0, 0, 0), 1, '16BUI', 10, 0) AS rast UNION ALL
SELECT 4, ST_AddBand(ST_MakeEmptyRaster(2, 2, 2, -2, 1, -1, 0, 0, 0), 1, '16BUI', 20, 0) AS rast UNION ALL
SELECT 5, ST_AddBand(ST_MakeEmptyRaster(2, 2, 4, -2, 1, -1, 0, 0, 0), 1, '16BUI', 30, 0) AS rast UNION ALL
SELECT 6, ST_AddBand(ST_MakeEmptyRaster(2, 2, 0, -4, 1, -1, 0, 0, 0), 1, '16BUI', 100, 0) AS rast UNION ALL
SELECT 7, ST_AddBand(ST_MakeEmptyRaster(2, 2, 2, -4, 1, -1, 0, 0, 0), 1, '16BUI', 200, 0) AS rast UNION ALL
SELECT 8, ST_AddBand(ST_MakeEmptyRaster(2, 2, 4, -4, 1, -1, 0, 0, 0), 1, '16BUI', 300, 0) AS rast
)
SELECT
t1.rid,
ST_MapAlgebra(ARRAY[ROW(ST_Union(t2.rast), 1)]::rastbandarg[],
'sample_callbackfunc(double precision[], int[], text[])'::regprocedure,
'32BUI',
'CUSTOM', t1.rast,
1, 1
) AS rast
FROM foo t1
CROSS JOIN foo t2
WHERE t1.rid = 4
AND t2.rid BETWEEN 0 AND 8
AND ST_Intersects(t1.rast, t2.rast)
GROUP BY t1.rid, t1.rast
Example like the prior one for tiles of a coverage with neighborhood but using only basic SQL features.
WITH src AS (
SELECT 0 AS rid, ST_AddBand(ST_MakeEmptyRaster(2, 2, 0, 0, 1, -1, 0, 0, 0), 1, '16BUI', 1, 0) AS rast UNION ALL
SELECT 1, ST_AddBand(ST_MakeEmptyRaster(2, 2, 2, 0, 1, -1, 0, 0, 0), 1, '16BUI', 2, 0) AS rast UNION ALL
SELECT 2, ST_AddBand(ST_MakeEmptyRaster(2, 2, 4, 0, 1, -1, 0, 0, 0), 1, '16BUI', 3, 0) AS rast UNION ALL
SELECT 3, ST_AddBand(ST_MakeEmptyRaster(2, 2, 0, -2, 1, -1, 0, 0, 0), 1, '16BUI', 10, 0) AS rast UNION ALL
SELECT 4, ST_AddBand(ST_MakeEmptyRaster(2, 2, 2, -2, 1, -1, 0, 0, 0), 1, '16BUI', 20, 0) AS rast UNION ALL
SELECT 5, ST_AddBand(ST_MakeEmptyRaster(2, 2, 4, -2, 1, -1, 0, 0, 0), 1, '16BUI', 30, 0) AS rast UNION ALL
SELECT 6, ST_AddBand(ST_MakeEmptyRaster(2, 2, 0, -4, 1, -1, 0, 0, 0), 1, '16BUI', 100, 0) AS rast UNION ALL
SELECT 7, ST_AddBand(ST_MakeEmptyRaster(2, 2, 2, -4, 1, -1, 0, 0, 0), 1, '16BUI', 200, 0) AS rast UNION ALL
SELECT 8, ST_AddBand(ST_MakeEmptyRaster(2, 2, 4, -4, 1, -1, 0, 0, 0), 1, '16BUI', 300, 0) AS rast
), foo AS (
SELECT
t1.rid,
ST_Union(t2.rast) AS rast
FROM src t1
JOIN src t2
ON ST_Intersects(t1.rast, t2.rast)
AND t2.rid BETWEEN 0 AND 8
WHERE t1.rid = 4
GROUP BY t1.rid
), bar AS (
SELECT
t1.rid,
ST_MapAlgebra(
ARRAY[ROW(t2.rast, 1)]::rastbandarg[],
'sample_callbackfunc(double precision[], int[], text[])'::regprocedure,
'32BUI',
'CUSTOM', t1.rast,
1, 1
) AS rast
FROM src t1
JOIN foo t2
ON t1.rid = t2.rid
)
SELECT
rid,
(ST_MetaData(rast)),
(ST_BandMetaData(rast, 1)),
ST_Value(rast, 1, 1, 1)
FROM bar;
Variants 2 and 3.
Ett raster, flera band
WITH foo AS (
SELECT 1 AS rid, ST_AddBand(ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(2, 2, 0, 0, 1, -1, 0, 0, 0), 1, '16BUI', 1, 0), 2, '8BUI', 10, 0), 3, '32BUI', 100, 0) AS rast
)
SELECT
ST_MapAlgebra(
rast,
ARRAY[3, 1, 3, 2]::integer[],
'sample_callbackfunc(double precision[], int[], text[])'::regprocedure
) AS rast
FROM foo
Ett raster, ett band
WITH foo AS (
SELECT 1 AS rid, ST_AddBand(ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(2, 2, 0, 0, 1, -1, 0, 0, 0), 1, '16BUI', 1, 0), 2, '8BUI', 10, 0), 3, '32BUI', 100, 0) AS rast
)
SELECT
ST_MapAlgebra(
rast,
2,
'sample_callbackfunc(double precision[], int[], text[])'::regprocedure
) AS rast
FROM foo
Variant 4.
Två rasters, två band
WITH foo AS (
SELECT 1 AS rid, ST_AddBand(ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(2, 2, 0, 0, 1, -1, 0, 0, 0), 1, '16BUI', 1, 0), 2, '8BUI', 10, 0), 3, '32BUI', 100, 0) AS rast UNION ALL
SELECT 2 AS rid, ST_AddBand(ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(2, 2, 0, 1, 1, -1, 0, 0, 0), 1, '16BUI', 2, 0), 2, '8BUI', 20, 0), 3, '32BUI', 300, 0) AS rast
)
SELECT
ST_MapAlgebra(
t1.rast,
2,
t2.rast,
1,
'sample_callbackfunc(double precision[], int[], text[])'::regprocedure
) AS rast
FROM foo t1
CROSS JOIN foo t2
WHERE t1.rid = 1
AND t2.rid = 2
ST_MapAlgebra (expression version) — Expression version - Returnerar ett enbandsraster med ett eller två indataraster, bandindex och ett eller flera användarspecifika SQL-uttryck.
raster ST_MapAlgebra(raster rast, integer nband, text pixeltype, text expression, double precision nodataval=NULL);
raster ST_MapAlgebra(raster rast, text pixeltype, text expression, double precision nodataval=NULL);
raster ST_MapAlgebra(raster rast1, integer nband1, raster rast2, integer nband2, text expression, text pixeltype=NULL, text extenttype=INTERSECTION, text nodata1expr=NULL, text nodata2expr=NULL, double precision nodatanodataval=NULL);
raster ST_MapAlgebra(raster rast1, raster rast2, text expression, text pixeltype=NULL, text extenttype=INTERSECTION, text nodata1expr=NULL, text nodata2expr=NULL, double precision nodatanodataval=NULL);
Expression version - Returnerar ett enbandsraster med ett eller två indataraster, bandindex och ett eller flera användarspecifika SQL-uttryck.
Tillgänglighet: 2.1.0
Skapar ett nytt raster med ett band som bildas genom att tillämpa en giltig PostgreSQL-algebraisk operation som definieras av uttrycket på inmatningsrastret(rast). Om nband inte tillhandahålls antas band 1. Den nya rastern kommer att ha samma georeferens, bredd och höjd som den ursprungliga rastern men kommer bara att ha ett band.
Om pixeltyp skickas in kommer det nya rastret att ha ett band av den pixeltypen. Om pixeltyp skickas till NULL kommer det nya rasterbandet att ha samma pixeltyp som det ingående rasterbandet.
Nyckelord som är tillåtna för uttryck
[rast] - Pixelvärdet för den intressanta pixeln
[rast.val] - Pixelvärdet för den intressanta pixeln
[rast.x] - 1-baserad pixelkolumn för den intressanta pixeln
[rast.y] - 1-baserad pixelrad för den intressanta pixeln
Skapar en ny enbandsraster som bildas genom att tillämpa en giltig PostgreSQL-algebraisk operation på de två banden som definieras av uttrycket på de två inmatningsrasterbanden rast1,(rast2). Om inget band1, band2 anges antas band 1. Det resulterande rastret kommer att vara justerat (skala, skevhet och pixelhörn) på det rutnät som definieras av det första rastret. Det resulterande rastret kommer att ha den utsträckning som definieras av parametern extenttype.
expressionEtt PostgreSQL-algebraiskt uttryck som involverar de två rasterna och PostgreSQL-definierade funktioner / operatorer som definierar pixelvärdet när pixlar korsar varandra. t.ex. (([rast1] + [rast2])/2.0):: heltal
pixeltypeDen resulterande pixeltypen för utdatarastern. Måste vara en som listas i ST_BandPixelType, utelämnas eller sätts till NULL. Om den inte skickas in eller sätts till NULL, kommer den första rastrets pixeltyp att användas som standard.
extenttypeStyr omfattningen av det resulterande rastret
INTERSECTION - Det nya rastrets utsträckning är skärningspunkten mellan de två rastren. Detta är standardinställningen.
UNION - Utbredningen av det nya rastret är en sammanslagning av de två rastren.
FIRST - Utbredningen av det nya rastret är densamma som för det första rastret.
SECOND - Utbredningen av det nya rastret är densamma som för det andra rastret.
nodata1exprEtt algebraiskt uttryck som endast omfattar rast2 eller en konstant som definierar vad som ska returneras när pixlar i rast1 har nodatavärden och spatialt motsvarande pixlar i rast2 har värden.
nodata2exprEtt algebraiskt uttryck som endast omfattar rast1 eller en konstant som definierar vad som ska returneras när pixlar i rast2 har nodatavärden och spatialt motsvarande pixlar i rast1 har värden.
nodatanodatavalEn numerisk konstant som returneras när spatialt motsvarande rast1- och rast2-pixlar båda är nodatavärden.
Nyckelord tillåtna i uttryck, nodata1expr och nodata2expr
[rast1] - Pixelvärdet för den intressanta pixeln från rast1
[rast1.val] - Pixelvärdet för den intressanta pixeln från rast1
[rast1.x] - 1-baserad pixelkolumn för den intressanta pixeln från rast1
[rast1.y] - 1-baserad pixelrad för den intressanta pixeln från rast1
[rast2] - Pixelvärdet för den intressanta pixeln från rast2
[rast2.val] - Pixelvärdet för den intressanta pixeln från rast2
[rast2.x] - 1-baserad pixelkolumn för den intressanta pixeln från rast2
[rast2.y] - 1-baserad pixelrad för den intressanta pixeln från rast2
Variants 1 and 2.
WITH foo AS (
SELECT ST_AddBand(ST_MakeEmptyRaster(10, 10, 0, 0, 1, 1, 0, 0, 0), '32BF'::text, 1, -1) AS rast
)
SELECT
ST_MapAlgebra(rast, 1, NULL, 'ceil([rast]*[rast.x]/[rast.y]+[rast.val])')
FROM foo;
Variant 3 and 4.
WITH foo AS (
SELECT 1 AS rid, ST_AddBand(ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(2, 2, 0, 0, 1, -1, 0, 0, 0), 1, '16BUI', 1, 0), 2, '8BUI', 10, 0), 3, '32BUI'::text, 100, 0) AS rast UNION ALL
SELECT 2 AS rid, ST_AddBand(ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(2, 2, 0, 1, 1, -1, 0, 0, 0), 1, '16BUI', 2, 0), 2, '8BUI', 20, 0), 3, '32BUI'::text, 300, 0) AS rast
)
SELECT
ST_MapAlgebra(
t1.rast,
2,
t2.rast,
1,
'([rast2] + [rast1.val]) / 2'
) AS rast
FROM foo t1
CROSS JOIN foo t2
WHERE t1.rid = 1
AND t2.rid = 2;
ST_MapAlgebraExpr — 1 raster band version: Skapar en ny enbandsraster som bildas genom att tillämpa en giltig PostgreSQL-algebraisk operation på inmatningsrasterbandet och av pixeltyp som tillhandahålls. Band 1 antas om inget band anges.
raster ST_MapAlgebraExpr(raster rast, integer band, text pixeltype, text expression, double precision nodataval=NULL);
raster ST_MapAlgebraExpr(raster rast, text pixeltype, text expression, double precision nodataval=NULL);
![]() | |
ST_MapAlgebraExpr är föråldrad från och med 2.1.0. Använd ST_MapAlgebra (expression version) istället. |
Skapar en ny raster med ett band som bildas genom att tillämpa en giltig PostgreSQL-algebraisk operation definierad av uttrycket på inmatningsrastern(rast). Om inget band anges antas band 1. Den nya rastern kommer att ha samma georeferens, bredd och höjd som den ursprungliga rastern men kommer bara att ha ett band.
Om pixeltyp skickas in kommer det nya rastret att ha ett band av den pixeltypen. Om pixeltyp skickas till NULL kommer det nya rasterbandet att ha samma pixeltyp som det ingående rasterbandet.
I uttrycket kan du använda termen [rast] för att hänvisa till pixelvärdet för originalbandet, [rast.x] för att hänvisa till det 1-baserade pixelkolumnindexet, [rast.y] för att hänvisa till det 1-baserade pixelradindexet.
Tillgänglighet: 2.0.0
Skapa ett nytt 1-bandsraster från vårt original som är en funktion av modulo 2 av det ursprungliga rasterbandet.
ALTER TABLE dummy_rast ADD COLUMN map_rast raster;
UPDATE dummy_rast SET map_rast = ST_MapAlgebraExpr(rast, NULL, 'mod([rast]::numeric,2)') WHERE rid = 2;
SELECT
ST_Value(rast, 1, i, j) As origval,
ST_Value(map_rast, 1, i, j) As mapval
FROM dummy_rast
CROSS JOIN generate_series(1, 3) AS i
CROSS JOIN generate_series(1, 3) AS j
WHERE rid = 2;origval | mapval
---------+--------
253 | 1
254 | 0
253 | 1
253 | 1
254 | 0
254 | 0
250 | 0
254 | 0
254 | 0Skapa ett nytt 1-bandsraster av pixeltyp 2BUI från vårt original som är omklassificerat och ställ in nodatavärdet till 0.
ALTER TABLE dummy_rast ADD COLUMN map_rast2 raster;
UPDATE dummy_rast SET
map_rast2 = ST_MapAlgebraExpr(rast, '2BUI'::text, 'CASE WHEN [rast] BETWEEN 100 and 250 THEN 1 WHEN [rast] = 252 THEN 2 WHEN [rast] BETWEEN 253 and 254 THEN 3 ELSE 0 END'::text, '0')
WHERE rid = 2;
SELECT DISTINCT
ST_Value(rast, 1, i, j) As origval,
ST_Value(map_rast2, 1, i, j) As mapval
FROM dummy_rast
CROSS JOIN generate_series(1, 5) AS i
CROSS JOIN generate_series(1, 5) AS j
WHERE rid = 2;origval | mapval
---------+--------
249 | 1
250 | 1
251 |
252 | 2
253 | 3
254 | 3SELECT
ST_BandPixelType(map_rast2) As b1pixtyp
FROM dummy_rast
WHERE rid = 2;2BUI
A self-contained source raster and the raster produced by classifying its values into four display levels.
WITH source AS (
SELECT ST_SetValues(
ST_AddBand(
ST_MakeEmptyRaster(8, 8, 0, 8, 1, -1, 0, 0, 0),
1, '8BUI', 0, 0
),
1, 1, 1,
ARRAY[
[0, 1, 2, 3, 4, 5, 6, 7],
[8, 9, 10, 11, 12, 13, 14, 15],
[16, 17, 18, 19, 20, 21, 22, 23],
[24, 25, 26, 27, 28, 29, 30, 31],
[32, 33, 34, 35, 36, 37, 38, 39],
[40, 41, 42, 43, 44, 45, 46, 47],
[48, 49, 50, 51, 52, 53, 54, 55],
[56, 57, 58, 59, 60, 61, 62, 63]
]::double precision[][]
) AS rast
), variants AS (
SELECT 'source' AS title, rast AS rendered
FROM source
UNION ALL
SELECT
'classified',
ST_MapAlgebraExpr(rast, '8BUI', 'floor([rast] / 16) * 85')
FROM source
)
SELECT title, ST_AsPNG(rendered) AS image
FROM variants
ORDER BY title DESC;title | image ------------+------------------------- source | PNG image, 8 x 8 pixels classified | PNG image, 8 x 8 pixels
Map algebra altering the first band of a three-band raster.
![]() original (kolumn rast_view) | ![]() rast_view_ma |
Skapa en ny 3-bandsraster samma pixeltyp från vår ursprungliga 3-bandsraster med första bandet ändrat av kartalgebra och återstående 2 band oförändrade.
SELECT
ST_AddBand(ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(rast_view),
ST_MapAlgebraExpr(rast_view, 1, NULL, 'tan([rast])*[rast]')
),
ST_Band(rast_view, 2)
),
ST_Band(rast_view, 3)
) As rast_view_ma
FROM wind
WHERE rid=167;
ST_MapAlgebraExpr — 2 rasterbandversion: Skapar en ny enbandsraster som bildas genom att tillämpa en giltig PostgreSQL-algebraisk operation på de två inmatningsrasterbanden och av pixeltyp som tillhandahålls. band 1 för varje raster antas om inga bandnummer anges. Den resulterande rastern kommer att justeras (skala, skevhet och pixelhörn) på det rutnät som definieras av den första rastern och ha sin utsträckning definierad av parametern "extenttype". Värden för "extenttype" kan vara: INTERSECTION, UNION, FIRST, SECOND.
raster ST_MapAlgebraExpr(raster rast1, raster rast2, text expression, text pixeltype=same_as_rast1_band, text extenttype=INTERSECTION, text nodata1expr=NULL, text nodata2expr=NULL, double precision nodatanodataval=NULL);
raster ST_MapAlgebraExpr(raster rast1, integer band1, raster rast2, integer band2, text expression, text pixeltype=same_as_rast1_band, text extenttype=INTERSECTION, text nodata1expr=NULL, text nodata2expr=NULL, double precision nodatanodataval=NULL);
![]() | |
ST_MapAlgebraExpr är föråldrad från och med 2.1.0. Använd ST_MapAlgebra (expression version) istället. |
Skapar en ny enbandsraster som bildas genom att tillämpa en giltig PostgreSQL-algebraisk operation på de två banden som definieras av uttrycket på de två inmatningsrasterbanden rast1,(rast2). Om inget band1, band2 anges antas band 1. Det resulterande rastret kommer att vara justerat (skala, skevhet och pixelhörn) på det rutnät som definieras av det första rastret. Det resulterande rastret kommer att ha den utsträckning som definieras av parametern extenttype.
expressionEtt PostgreSQL-algebraiskt uttryck som involverar de två rasterna och PostgreSQL-definierade funktioner / operatorer som definierar pixelvärdet när pixlar korsar varandra. t.ex. (([rast1] + [rast2])/2.0):: heltal
pixeltypeDen resulterande pixeltypen för utdatarastern. Måste vara en som listas i ST_BandPixelType, utelämnas eller sätts till NULL. Om den inte skickas in eller sätts till NULL, kommer den första rastrets pixeltyp att användas som standard.
extenttypeStyr omfattningen av det resulterande rastret
INTERSECTION - Det nya rastrets utsträckning är skärningspunkten mellan de två rastren. Detta är standardinställningen.
UNION - Utbredningen av det nya rastret är en sammanslagning av de två rastren.
FIRST - Utbredningen av det nya rastret är densamma som för det första rastret.
SECOND - Utbredningen av det nya rastret är densamma som för det andra rastret.
nodata1exprEtt algebraiskt uttryck som endast omfattar rast2 eller en konstant som definierar vad som ska returneras när pixlar i rast1 har nodatavärden och spatialt motsvarande pixlar i rast2 har värden.
nodata2exprEtt algebraiskt uttryck som endast omfattar rast1 eller en konstant som definierar vad som ska returneras när pixlar i rast2 har nodatavärden och spatialt motsvarande pixlar i rast1 har värden.
nodatanodatavalEn numerisk konstant som returneras när spatialt motsvarande rast1- och rast2-pixlar båda är nodatavärden.
Om pixeltype skickas in kommer det nya rastret att ha ett band av den pixeltypen. Om pixeltype skickas till NULL eller ingen pixeltyp anges, kommer det nya rasterbandet att ha samma pixeltyp som det inmatade rast1-bandet.
Använd termen [rast1. val] [rast2.val] för att hänvisa till pixelvärdet för de ursprungliga rasterbanden och [rast1. x], [rast1. y] etc. för att hänvisa till pixlarnas kolumn-/radpositioner.
Tillgänglighet: 2.0.0
2 Band Intersection and Union.
Skapa ett nytt 1-bandsraster från vårt original som är en funktion av modulo 2 av det ursprungliga rasterbandet.
Create a cool set of rasters.
Insert some cool shapes around Boston in Massachusetts state plane meters, then map their intersection and union.
DROP TABLE IF EXISTS fun_shapes;
CREATE TABLE fun_shapes(rid serial PRIMARY KEY, fun_name text, rast raster);
INSERT INTO fun_shapes(fun_name, rast)
VALUES ('ref', ST_AsRaster(ST_MakeEnvelope(235229, 899970, 237229, 901930, 26986), 200, 200, '8BUI', 0, 0));
INSERT INTO fun_shapes(fun_name, rast)
WITH ref(rast) AS (SELECT rast FROM fun_shapes WHERE fun_name = 'ref' )
SELECT 'area' AS fun_name, ST_AsRaster(ST_Buffer(ST_SetSRID(ST_Point(236229, 900930), 26986), 1000),
ref.rast, '8BUI', 10, 0) As rast
FROM ref
UNION ALL
SELECT 'rand bubbles',
ST_AsRaster(
(
SELECT ST_Collect(geom)
FROM (
SELECT ST_Buffer(
ST_SetSRID(ST_Point(236229 + i*random()*100, 900930 + j*random()*100), 26986),
random()*20
) AS geom
FROM generate_series(1, 10) AS i,
generate_series(1, 10) AS j
) AS foo
),
ref.rast, '8BUI', 200, 0
)
FROM ref;
SELECT ST_MapAlgebraExpr(area.rast, bub.rast, '[rast2.val]', '8BUI', 'INTERSECTION', '[rast2.val]', '[rast1.val]') As interrast,
ST_MapAlgebraExpr(area.rast, bub.rast, '[rast2.val]', '8BUI', 'UNION', '[rast2.val]', '[rast1.val]') As unionrast
FROM
(SELECT rast FROM fun_shapes WHERE fun_name = 'area') As area
CROSS JOIN
(SELECT rast FROM fun_shapes WHERE fun_name = 'rand bubbles') As bub
The same intersection and union operations using two deterministic, self-contained rasters.
WITH canvas AS (
SELECT ST_AddBand(
ST_MakeEmptyRaster(80, 80, 0, 80, 1, -1, 0, 0, 0),
1, '8BUI', 40, 0
) AS rast
), inputs AS (
SELECT
rast AS raster_1,
ST_AsRaster(
ST_Buffer(ST_Point(40, 40), 28),
rast,
'8BUI', 220, 0
) AS raster_2
FROM canvas
), variants AS (
SELECT 'raster 1' AS title, raster_1 AS rendered FROM inputs
UNION ALL
SELECT 'raster 2', raster_2 FROM inputs
UNION ALL
SELECT 'intersection', ST_MapAlgebraExpr(
raster_1, raster_2,
'[rast2.val]', '8BUI', 'INTERSECTION',
'[rast2.val]', '[rast1.val]'
) FROM inputs
UNION ALL
SELECT 'union', ST_MapAlgebraExpr(
raster_1, raster_2,
'[rast2.val]', '8BUI', 'UNION',
'[rast2.val]', '[rast1.val]'
) FROM inputs
)
SELECT title, ST_AsPNG(rendered) AS image
FROM variants
ORDER BY CASE title
WHEN 'raster 1' THEN 1
WHEN 'raster 2' THEN 2
WHEN 'intersection' THEN 3
ELSE 4
END;title | image --------------+--------------------------- raster 1 | PNG image, 80 x 80 pixels raster 2 | PNG image, 56 x 56 pixels intersection | PNG image, 56 x 56 pixels union | PNG image, 80 x 80 pixels
Overlaying rasters on a one-unit-per-pixel canvas as separate bands. We use ST_AsPNG to render the image so all single band ones look grey.
WITH mygeoms AS (
SELECT 2 AS bnum, ST_Buffer(ST_Point(1, 5), 10) AS geom
UNION ALL
SELECT 3,
ST_Buffer(
ST_GeomFromText('LINESTRING(50 50,150 150,150 50)'),
10,
'join=bevel'
)
UNION ALL
SELECT 1,
ST_Buffer(
ST_GeomFromText('LINESTRING(60 50,150 150,150 50)'),
5,
'join=bevel'
)
), canvas AS (
SELECT ST_AddBand(
ST_MakeEmptyRaster(
200,
200,
ST_XMin(e)::integer,
ST_YMax(e)::integer,
1, -1, 0, 0),
'8BUI'::text,
0
) AS rast
FROM (
SELECT ST_Extent(geom) AS e
FROM mygeoms
) AS bounds
), rbands AS (
SELECT ARRAY(
SELECT ST_MapAlgebraExpr(
canvas.rast,
ST_AsRaster(m.geom, canvas.rast, '8BUI', 100),
'[rast2.val]', '8BUI', 'FIRST',
'[rast2.val]', '[rast1.val]'
)
FROM mygeoms AS m
CROSS JOIN canvas
ORDER BY m.bnum
) AS rasts
)
SELECT title, ST_AsPNG(rendered) AS image
FROM rbands
CROSS JOIN LATERAL (VALUES
('band 1', rasts[1]),
('band 2', rasts[2]),
('band 3', rasts[3]),
('RGB', ST_AddBand(ST_AddBand(rasts[1], rasts[2]), rasts[3]))
) AS variants(title, rendered);title | image --------+----------------------------- band 1 | PNG image, 200 x 200 pixels band 2 | PNG image, 200 x 200 pixels band 3 | PNG image, 200 x 200 pixels RGB | PNG image, 200 x 200 pixels
Overlay a two-meter boundary of selected parcels over aerial imagery. The query first unions the parcel geometries, clips the source raster shards to the region, unions those smaller shards, and finally adds the first two bands plus a third-band map algebra overlay.
Create a new three-band raster composed of the first two clipped bands and the third band overlaid with the geometry. This query took 3.6 seconds on a 64-bit PostGIS Windows installation.
WITH pr AS (
SELECT ST_Clip(rast, ST_Expand(geom, 50)) AS rast, g.geom
FROM aerials.o_2_boston AS r
INNER JOIN (
SELECT ST_Union(ST_Transform(geom, 26986)) AS geom
FROM landparcels
WHERE pid IN ('0303890000', '0303900000')
) AS g
ON ST_Intersects(rast::geometry, ST_Expand(g.geom, 50))
), prunion AS (
SELECT ST_AddBand(
NULL,
ARRAY[
ST_Union(rast, 1),
ST_Union(rast, 2),
ST_Union(rast, 3)
]
) AS clipped,
geom
FROM pr
GROUP BY geom
)
SELECT ST_AddBand(
ST_Band(clipped, ARRAY[1, 2]),
ST_MapAlgebraExpr(
ST_Band(clipped, 3),
ST_AsRaster(ST_Buffer(ST_Boundary(geom), 2), clipped, '8BUI', 250),
'[rast2.val]',
'8BUI',
'FIRST',
'[rast2.val]',
'[rast1.val]') ) As rast
FROM prunion;
Parcel-boundary overlay.
![]() The blue lines are the boundaries of selected parcels |
The generated four-panel canvas example above shows the same band-overlay technique without requiring an external aerial-imagery or parcel table.
ST_MapAlgebraFct — 1 bandversion - Skapar en ny enbandsraster som bildas genom att tillämpa en giltig PostgreSQL-funktion på inmatningsrasterbandet och av pixeltyp som tillhandahålls. Band 1 antas om inget band anges.
raster ST_MapAlgebraFct(raster rast, regprocedure onerasteruserfunc);
raster ST_MapAlgebraFct(raster rast, regprocedure onerasteruserfunc, text[] VARIADIC args);
raster ST_MapAlgebraFct(raster rast, text pixeltype, regprocedure onerasteruserfunc);
raster ST_MapAlgebraFct(raster rast, text pixeltype, regprocedure onerasteruserfunc, text[] VARIADIC args);
raster ST_MapAlgebraFct(raster rast, integer band, regprocedure onerasteruserfunc);
raster ST_MapAlgebraFct(raster rast, integer band, regprocedure onerasteruserfunc, text[] VARIADIC args);
raster ST_MapAlgebraFct(raster rast, integer band, text pixeltype, regprocedure onerasteruserfunc);
raster ST_MapAlgebraFct(raster rast, integer band, text pixeltype, regprocedure onerasteruserfunc, text[] VARIADIC args);
![]() | |
ST_MapAlgebraFct är föråldrad från och med 2.1.0. Använd ST_MapAlgebra (callback function version) istället. |
Skapar ett nytt ettbandsraster som bildas genom att tillämpa en giltig PostgreSQL-funktion som anges av onerasteruserfunc på inmatningsrastret(rast). Om inget band anges antas band 1. Det nya rastret kommer att ha samma georeferens, bredd och höjd som det ursprungliga rastret men kommer bara att ha ett band.
Om pixeltyp skickas in kommer det nya rastret att ha ett band av den pixeltypen. Om pixeltyp skickas till NULL kommer det nya rasterbandet att ha samma pixeltyp som det ingående rasterbandet.
Parametern onerasteruserfunc måste vara namnet och signaturen för en SQL- eller PL/pgSQL-funktion, som kastas till en regprocedure. Ett mycket enkelt och ganska värdelöst PL / pgSQL-funktionsexempel är:
CREATE OR REPLACE FUNCTION simple_function(pixel FLOAT, pos INTEGER[], VARIADIC args TEXT[])
RETURNS FLOAT
AS $$ BEGIN
RETURN 0.0;
END; $$
LANGUAGE 'plpgsql' IMMUTABLE;Användarfunktionen kan ta emot två eller tre argument: ett floatvärde, en valfri heltalsarray och en variadisk textarray. Det första argumentet är värdet för en enskild rastercell (oberoende av rasterdatatyp). Det andra argumentet är positionen för den aktuella bearbetningscellen i formen '{x,y}'. Det tredje argumentet anger att alla återstående parametrar till ST_MapAlgebraFct ska skickas vidare till användarfunktionen.
För att skicka ett regprodedure-argument till en SQL-funktion krävs att hela funktionssignaturen skickas och sedan kastas till en regprocedure-typ. För att skicka ovanstående exempel på PL / pgSQL-funktion som ett argument är SQL för argumentet:
'simple_function(float,integer[],text[])'::regprocedure
Observera att argumentet innehåller namnet på funktionen, typerna av funktionsargumenten, citattecken runt namnet och argumenttyperna och en cast till en regprocedure.
Det tredje argumentet till användarfunktionen är en variadisk textmatris. Alla efterföljande textargument i ett anrop till ST_MapAlgebraFct skickas vidare till den angivna användarfunktionen och ingår i argumentet args.
![]() | |
För mer information om VARIADIC-nyckelordet, se PostgreSQL-dokumentationen och avsnittet "SQL-funktioner med variabelt antal argument" i Query Language (SQL) -funktioner. |
![]() | |
Argumentet text[] till |
Tillgänglighet: 2.0.0
Skapa ett nytt 1-bandsraster från vårt original som är en funktion av modulo 2 av det ursprungliga rasterbandet.
ALTER TABLE dummy_rast ADD COLUMN map_rast raster;
CREATE FUNCTION mod_fct(pixel float, pos integer[], variadic args text[])
RETURNS float
AS $$
BEGIN
RETURN pixel::integer % 2;
END;
$$
LANGUAGE 'plpgsql' IMMUTABLE;
UPDATE dummy_rast SET map_rast = ST_MapAlgebraFct(rast, NULL, 'mod_fct(float,integer[],text[])'::regprocedure) WHERE rid = 2;
SELECT ST_Value(rast, 1, i, j) As origval, ST_Value(map_rast, 1, i, j) As mapval
FROM dummy_rast CROSS JOIN generate_series(1, 3) AS i CROSS JOIN generate_series(1, 3) AS j
WHERE rid = 2;origval | mapval
---------+--------
253 | 1
254 | 0
253 | 1
253 | 1
254 | 0
254 | 0
250 | 0
254 | 0
254 | 0Skapa ett nytt 1-bandsraster av pixeltyp 2BUI från vårt original som omklassificeras och ställ in nodatavärdet till en passerad parameter till användarfunktionen (0).
ALTER TABLE dummy_rast ADD COLUMN map_rast2 raster;
CREATE FUNCTION classify_fct(pixel float, pos integer[], variadic args text[])
RETURNS float
AS
$$
DECLARE
nodata float := 0;
BEGIN
IF NOT args[1] IS NULL THEN
nodata := args[1];
END IF;
IF pixel < 251 THEN
RETURN 1;
ELSIF pixel = 252 THEN
RETURN 2;
ELSIF pixel
> 252 THEN
RETURN 3;
ELSE
RETURN nodata;
END IF;
END;
$$
LANGUAGE 'plpgsql';
UPDATE dummy_rast SET map_rast2 = ST_MapAlgebraFct(rast,'2BUI','classify_fct(float,integer[],text[])'::regprocedure, '0') WHERE rid = 2;
SELECT DISTINCT ST_Value(rast,1,i,j) As origval, ST_Value(map_rast2, 1, i, j) As mapval
FROM dummy_rast CROSS JOIN generate_series(1, 5) AS i CROSS JOIN generate_series(1,5) AS j
WHERE rid = 2; origval | mapval
---------+--------
249 | 1
250 | 1
251 |
252 | 2
253 | 3
254 | 3SELECT ST_BandPixelType(map_rast2) As b1pixtyp FROM dummy_rast WHERE rid = 2;
b1pixtyp ---------- 2BUI
Skapa en ny 3-bandsraster samma pixeltyp från vår ursprungliga 3-bandsraster med första bandet ändrat av kartalgebra och återstående 2 band oförändrade.
CREATE FUNCTION rast_plus_tan(pixel float, pos integer[], variadic args text[])
RETURNS float
AS
$$
BEGIN
RETURN tan(pixel) * pixel;
END;
$$
LANGUAGE 'plpgsql';
SELECT ST_AddBand(ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(rast_view),
ST_MapAlgebraFct(rast_view, 1, NULL, 'rast_plus_tan(float,integer[],text[])'::regprocedure)
),
ST_Band(rast_view, 2)
),
ST_Band(rast_view, 3) As rast_view_ma
)
FROM wind
WHERE rid=167;
The deprecated callback form above is equivalent to a modern ST_MapAlgebra (callback function version) expression for simple per-pixel transforms. This build-time example renders the original raster and a modulo-2 classification.
WITH pixels AS (
SELECT x, y, (x + y * 2)::double precision AS value
FROM generate_series(1, 48) AS x
CROSS JOIN generate_series(1, 48) AS y
), rows AS (
SELECT y, array_agg(value ORDER BY x) AS values
FROM pixels
GROUP BY y
), source AS (
SELECT ST_SetValues(
ST_AddBand(
ST_MakeEmptyRaster(48, 48, 0, 48, 1, -1, 0, 0, 0),
1, '8BUI', 0, 0
),
1, 1, 1, array_agg(values ORDER BY y)::double precision[][]
) AS rast
FROM rows
), variants AS (
SELECT 'source' AS title, rast AS rendered FROM source
UNION ALL
SELECT 'modulo 2', ST_MapAlgebra(
rast, 1,
'8BUI',
'mod([rast]::integer,2) * 255'
)
FROM source
)
SELECT title, ST_AsPNG(rendered) AS image
FROM variants
ORDER BY title DESC;title | image ----------+------------------------- source | PNG image, 48 x 48 pixels modulo 2 | PNG image, 48 x 48 pixels
ST_MapAlgebraFct — 2 band version - Skapar en ny enbandsraster som bildas genom att tillämpa en giltig PostgreSQL-funktion på de 2 inmatningsrasterbanden och av pixeltyp som tillhandahålls. Band 1 antas om inget band anges. Utsträckningstyp är som standard INTERSECTION om den inte anges.
raster ST_MapAlgebraFct(raster rast1, raster rast2, regprocedure tworastuserfunc, text pixeltype=same_as_rast1, text extenttype=INTERSECTION, text[] VARIADIC userargs);
raster ST_MapAlgebraFct(raster rast1, integer band1, raster rast2, integer band2, regprocedure tworastuserfunc, text pixeltype=same_as_rast1, text extenttype=INTERSECTION, text[] VARIADIC userargs);
![]() | |
ST_MapAlgebraFct är föråldrad från och med 2.1.0. Använd ST_MapAlgebra (callback function version) istället. |
Skapar ett nytt ettbandsraster som bildas genom att tillämpa en giltig PostgreSQL-funktion som anges av tworastuserfunc på inmatningsrastret rast1, rast2. Om inget band1 eller band2 anges antas band 1. Det nya rastret kommer att ha samma georeferens, bredd och höjd som de ursprungliga rastren men kommer bara att ha ett band.
Om pixeltype skickas in kommer det nya rastret att ha ett band av den pixeltypen. Om pixeltype skickas som NULL eller utelämnas kommer det nya rasterbandet att ha samma pixeltype som det ingående rast1-bandet.
Parametern tworastuserfunc måste vara namnet och signaturen för en SQL- eller PL/pgSQL-funktion, som kastas till en regprocedure. Ett exempel på PL/pgSQL-funktionsexempel är:
CREATE OR REPLACE FUNCTION simple_function_for_two_rasters(pixel1 FLOAT, pixel2 FLOAT, pos INTEGER[], VARIADIC args TEXT[])
RETURNS FLOAT
AS $$ BEGIN
RETURN 0.0;
END; $$
LANGUAGE 'plpgsql' IMMUTABLE;Tworastuserfunc kan acceptera tre eller fyra argument: ett värde med dubbel precision, ett värde med dubbel precision, en valfri heltalsarray och en variadisk textarray. Det första argumentet är värdet för en enskild rastercell i rast1 (oavsett rasterdatatyp). Det andra argumentet är ett individuellt rastercellsvärde i rast2. Det tredje argumentet är positionen för den aktuella bearbetningscellen i formen '{x,y}'. Det fjärde argumentet anger att alla återstående parametrar till ST_MapAlgebraFct ska skickas vidare till tworastuserfunc.
För att skicka ett regprodedure-argument till en SQL-funktion krävs att hela funktionssignaturen skickas och sedan kastas till en regprocedure-typ. För att skicka ovanstående exempel på PL / pgSQL-funktion som ett argument är SQL för argumentet:
'simple_function(double precision, double precision, integer[], text[])'::regprocedure
Observera att argumentet innehåller namnet på funktionen, typerna av funktionsargumenten, citattecken runt namnet och argumenttyperna och en cast till en regprocedure.
Det fjärde argumentet till tworastuserfunc är en variadisk textmatris. Alla efterföljande textargument till ett ST_MapAlgebraFct -anrop skickas vidare till den angivna tworastuserfunc och ingår i argumentet userargs.
![]() | |
För mer information om VARIADIC-nyckelordet, se PostgreSQL-dokumentationen och avsnittet "SQL-funktioner med variabelt antal argument" i Query Language (SQL) -funktioner. |
![]() | |
Argumentet text[] till |
Tillgänglighet: 2.0.0
The deprecated two-raster callback form can often be expressed with the modern two-raster ST_MapAlgebra (callback function version) expression variant. This build-time example renders two input rasters and their averaged overlap.
WITH canvas AS (
SELECT ST_AddBand(
ST_MakeEmptyRaster(80, 80, 0, 80, 1, -1, 0, 0, 0),
1, '8BUI', 0, 0
) AS rast
), inputs AS (
SELECT
ST_AsRaster(ST_Buffer(ST_Point(30, 40), 25), rast, '8BUI', 80, 0)
AS raster_1,
ST_AsRaster(ST_Buffer(ST_Point(50, 40), 25), rast, '8BUI', 220, 0)
AS raster_2
FROM canvas
), variants AS (
SELECT 'raster 1' AS title, raster_1 AS rendered FROM inputs
UNION ALL
SELECT 'raster 2', raster_2 FROM inputs
UNION ALL
SELECT 'averaged', ST_MapAlgebra(
raster_1, 1,
raster_2, 1,
'([rast1] + [rast2]) / 2',
'8BUI',
'UNION'
) FROM inputs
)
SELECT title, ST_AsPNG(rendered) AS image
FROM variants
ORDER BY title DESC;title | image ----------+------------------------- raster 2 | PNG image, 50 x 50 pixels raster 1 | PNG image, 50 x 50 pixels averaged | PNG image, 70 x 50 pixels
Define our user defined function.
CREATE OR REPLACE FUNCTION raster_mapalgebra_union(
rast1 double precision,
rast2 double precision,
pos integer[],
VARIADIC userargs text[]
)
RETURNS double precision
AS $$
DECLARE
BEGIN
CASE
WHEN rast1 IS NOT NULL AND rast2 IS NOT NULL THEN
RETURN ((rast1 + rast2)/2.);
WHEN rast1 IS NULL AND rast2 IS NULL THEN
RETURN NULL;
WHEN rast1 IS NULL THEN
RETURN rast2;
ELSE
RETURN rast1;
END CASE;
RETURN NULL;
END;
$$ LANGUAGE 'plpgsql' IMMUTABLE COST 1000;
Prepare a test table of rasters.
DROP TABLE IF EXISTS map_shapes;
CREATE TABLE map_shapes(rid serial PRIMARY KEY, rast raster, bnum integer, descrip text);
INSERT INTO map_shapes(rast,bnum, descrip)
WITH mygeoms
AS ( SELECT 2 As bnum, ST_Buffer(ST_Point(90,90),30) As geom, 'circle' As descrip
UNION ALL
SELECT 3 AS bnum,
ST_Buffer(ST_GeomFromText('LINESTRING(50 50,150 150,150 50)'), 15) As geom, 'big road' As descrip
UNION ALL
SELECT 1 As bnum,
ST_Translate(ST_Buffer(ST_GeomFromText('LINESTRING(60 50,150 150,150 50)'), 8,'join=bevel'), 10,-6) As geom, 'small road' As descrip
),
-- define our canvas to be 1 to 1 pixel to geometry
canvas
AS ( SELECT ST_AddBand(
ST_MakeEmptyRaster(
250,
250,
ST_XMin(e)::integer,
ST_YMax(e)::integer,
1, -1, 0, 0),
'8BUI'::text,
0) As rast
FROM (SELECT ST_Extent(geom) As e,
Max(ST_SRID(geom)) As srid
from mygeoms
) As foo
)
-- return our rasters aligned with our canvas
SELECT ST_AsRaster(m.geom, canvas.rast, '8BUI', 240) As rast, bnum, descrip
FROM mygeoms AS m CROSS JOIN canvas
UNION ALL
SELECT canvas.rast, 4, 'canvas'
FROM canvas;
Map algebra on single-band rasters and then collect the result with ST_AddBand.
INSERT INTO map_shapes(rast,bnum,descrip)
SELECT ST_AddBand(ST_AddBand(rasts[1], rasts[2]),rasts[3]), 4, 'map bands overlay fct union (canvas)'
FROM (SELECT ARRAY(SELECT ST_MapAlgebraFct(
m1.rast,
m2.rast,
'raster_mapalgebra_union(double precision, double precision, integer[], text[])'::regprocedure,
'8BUI',
'FIRST')
FROM map_shapes As m1 CROSS JOIN map_shapes As m2
WHERE m1.descrip = 'canvas' AND m2.descrip <
> 'canvas' ORDER BY m2.bnum) As rasts) As foo;
A compact, executable callback example. The source rasters and their averaged overlap are rendered at build time.
CREATE OR REPLACE FUNCTION pg_temp.raster_average(
value_1 double precision,
value_2 double precision,
position integer[],
VARIADIC userargs text[]
) RETURNS double precision
LANGUAGE SQL IMMUTABLE
AS 'SELECT COALESCE(($1 + $2) / 2.0, $1, $2)';
WITH canvas AS (
SELECT ST_AddBand(
ST_MakeEmptyRaster(80, 80, 0, 80, 1, -1, 0, 0, 0),
1, '8BUI', 0, 0
) AS rast
), inputs AS (
SELECT
ST_AsRaster(ST_Buffer(ST_Point(30, 40), 25), rast, '8BUI', 80, 0)
AS raster_1,
ST_AsRaster(ST_Buffer(ST_Point(50, 40), 25), rast, '8BUI', 220, 0)
AS raster_2
FROM canvas
), variants AS (
SELECT 'raster 1' AS title, raster_1 AS rendered FROM inputs
UNION ALL
SELECT 'raster 2', raster_2 FROM inputs
UNION ALL
SELECT 'averaged', ST_MapAlgebraFct(
raster_1,
raster_2,
'pg_temp.raster_average(double precision,double precision,integer[],text[])'::regprocedure,
'8BUI',
'UNION'
) FROM inputs
)
SELECT title, ST_AsPNG(rendered) AS image
FROM variants
ORDER BY title DESC;title | image ----------+--------------------------- raster 2 | PNG image, 50 x 50 pixels raster 1 | PNG image, 50 x 50 pixels averaged | PNG image, 70 x 50 pixels
CREATE OR REPLACE FUNCTION raster_mapalgebra_userargs(
rast1 double precision,
rast2 double precision,
pos integer[],
VARIADIC userargs text[]
)
RETURNS double precision
AS $$
DECLARE
BEGIN
CASE
WHEN rast1 IS NOT NULL AND rast2 IS NOT NULL THEN
RETURN least(userargs[1]::integer,(rast1 + rast2)/2.);
WHEN rast1 IS NULL AND rast2 IS NULL THEN
RETURN userargs[2]::integer;
WHEN rast1 IS NULL THEN
RETURN greatest(rast2, random()*userargs[3]::integer)::integer;
ELSE
RETURN greatest(rast1, random()*userargs[4]::integer)::integer;
END CASE;
RETURN NULL;
END;
$$ LANGUAGE 'plpgsql' VOLATILE COST 1000;
SELECT ST_MapAlgebraFct(
m1.rast,
1,
m1.rast,
3,
'raster_mapalgebra_userargs(double precision, double precision, integer[], text[])'::regprocedure,
'8BUI',
'INTERSECT',
'100', '200', '200', '0')
FROM map_shapes As m1
WHERE m1.descrip = 'map bands overlay fct union (canvas)';
The generated callback figure above demonstrates the raster alignment and overlap used by this variant; the exact callback result remains available as text.
ST_MapAlgebraFctNgb — 1-bandsversion: Kartlägg Algebra närmaste granne med hjälp av användardefinierad PostgreSQL-funktion. Returnera en raster vars värden är resultatet av en PLPGSQL-användarfunktion som involverar ett grannskap av värden från inmatningsrasterbandet.
raster ST_MapAlgebraFctNgb(raster rast, integer band, text pixeltype, integer ngbwidth, integer ngbheight, regprocedure onerastngbuserfunc, text nodatamode, text[] VARIADIC args);
![]() | |
ST_MapAlgebraFctNgb är föråldrad från och med 2.1.0. Använd ST_MapAlgebra (callback function version) istället. |
(en rasterversion) Returnera en raster vars värden är resultatet av en PLPGSQL-användarfunktion som involverar ett grannskap av värden från inmatningsrasterbandet. Användarfunktionen tar grannskapet av pixelvärden som en matris med siffror, för varje pixel, returnerar resultatet från användarfunktionen och ersätter pixelvärdet för den för närvarande inspekterade pixeln med funktionsresultatet.
rastRaster på vilket användarfunktionen utvärderas.
bandBandnummer för det raster som ska utvärderas. Standardvärdet är 1.
pixeltypeDen resulterande pixeltypen för utdatarastern. Måste vara en som listas i ST_BandPixelType eller utelämnas eller sätts till NULL. Om den inte skickas in eller sätts till NULL, kommer pixeltypen för rastret att användas som standard. Resultaten trunkeras om de är större än vad som är tillåtet för pixeltypen.
ngbwidthBredden på grannskapet, i celler.
ngbheightHöjden på kvarteret, i celler.
onerastngbuserfuncPLPGSQL / psql-användarfunktion för att applicera på grannskapspixlar i ett enda band av en raster. Det första elementet är en 2-dimensionell matris med siffror som representerar den rektangulära pixelgrannskapet
nodatamodeDefinierar vilket värde som ska skickas till funktionen för en grannskapspixel som är nodata eller NULL
'ignore': alla NODATA-värden som påträffas i grannskapet ignoreras av beräkningen -- denna flagga måste skickas till användarens återuppringningsfunktion, och användarfunktionen avgör hur den ska ignoreras.
"NULL": alla NODATA-värden som påträffas i grannskapet gör att den resulterande pixeln blir NULL - användarens återuppringningsfunktion hoppas över i detta fall.
"value": alla NODATA-värden som påträffas i grannskapet ersätts av referenspixeln (den i mitten av grannskapet). Observera att om detta värde är NODATA är beteendet detsamma som 'NULL' (för den berörda grannskapet)
argsArgument som ska skickas till användarfunktionen.
Tillgänglighet: 2.0.0
Exemplen använder katrina-raster som lästs in som en enda bricka som beskrivs i https://gdal.org/user/drivers/raster/postgisraster.html och sedan förberetts i exemplen ST_Rescale
A simple 'callback' user function that averages up all the values in a neighborhood.
CREATE OR REPLACE FUNCTION rast_avg(matrix float[][], nodatamode text, variadic args text[])
RETURNS float AS
$$
DECLARE
_matrix float[][];
x1 integer;
x2 integer;
y1 integer;
y2 integer;
sum float;
BEGIN
_matrix := matrix;
sum := 0;
FOR x in array_lower(matrix, 1)..array_upper(matrix, 1) LOOP
FOR y in array_lower(matrix, 2)..array_upper(matrix, 2) LOOP
sum := sum + _matrix[x][y];
END LOOP;
END LOOP;
RETURN (sum*1.0/(array_upper(matrix,1)*array_upper(matrix,2) ))::integer ;
END;
$$
LANGUAGE 'plpgsql' IMMUTABLE COST 1000;
Apply the raster averaging callback within two pixels of each input pixel in the X and Y directions.
SELECT ST_MapAlgebraFctNgb(
rast,
1,
'8BUI',
4,
4,
'rast_avg(float[][], text, text[])'::regprocedure,
'NULL',
NULL) As nn_with_border
FROM katrinas_rescaled
limit 1;
A self-contained neighborhood average. The source raster has a sharp central square, while the result spreads those values across neighboring pixels. The source uses a non-NODATA background so nodatamode ignore averages background values with the square values, instead of treating the background as absent.
WITH source AS (
SELECT ST_SetValues(
ST_AddBand(
ST_MakeEmptyRaster(16, 16, 0, 16, 1, -1, 0, 0, 0),
1, '8BUI', 25, NULL
),
1, 6, 6,
ARRAY[
[240, 240, 240, 240, 240, 240],
[240, 240, 240, 240, 240, 240],
[240, 240, 240, 240, 240, 240],
[240, 240, 240, 240, 240, 240],
[240, 240, 240, 240, 240, 240],
[240, 240, 240, 240, 240, 240]
]::double precision[][]
) AS rast
), variants AS (
SELECT 'source' AS title, rast AS rendered FROM source
UNION ALL
SELECT 'averaged', ST_SetBandNoDataValue(ST_MapAlgebraFctNgb(
rast,
1,
'8BUI',
2,
2,
'ST_Mean4ma(float[][],text,text[])'::regprocedure,
'ignore',
NULL
), NULL) FROM source
)
SELECT title, ST_AsPNG(rendered) AS image
FROM variants
ORDER BY title DESC;title | image ----------+------------------------- source | PNG image, 16 x 16 pixels averaged | PNG image, 16 x 16 pixels
Neighborhood averaging.
![]() Första bandet av vår raster | ![]() Averaged result |
ST_Reclass — Skapar ett nytt raster som består av bandtyper som omklassificerats från originalet. Nband är det band som ska ändras. Om nband inte anges antas värdet vara 1. Alla andra band returneras oförändrade. Användningsfall: konvertera ett 16BUI-band till ett 8BUI och så vidare för enklare rendering som visningsbara format.
raster ST_Reclass(raster rast, integer nband, text reclassexpr, text pixeltype, double precision nodataval=NULL);
raster ST_Reclass(raster rast, reclassarg[] VARIADIC reclassargset);
raster ST_Reclass(raster rast, text reclassexpr, text pixeltype);
Skapar ett nytt raster som bildas genom att tillämpa en omklassificeringsoperation som definieras av reclassexpr på indatarastret(rast). Se reclassarg för en beskrivning av omklassificeringsuttryck. Om inget band anges antas band 1.
Det nya rastret kommer att ha samma georeferens, bredd och höjd som det ursprungliga rastret. Banden i det nya rastret har pixeltyp av pixeltype. Om reclassargset specificeras definierar varje reclassarg typen av målband. Band som inte har angetts returneras oförändrade.
Tillgänglighet: 2.0.0
Basic.
Skapa ett nytt raster från originalet där band 2 konverteras från 8BUI till 4BUI och alla värden från 101-254 sätts till nodatavärde.
ALTER TABLE dummy_rast ADD COLUMN reclass_rast raster;
UPDATE dummy_rast SET reclass_rast = ST_Reclass(rast, 2, '0-87:1-10, 88-100:11-15, 101-254:0-0', '4BUI', 0) WHERE rid = 2;
SELECT i as col, j as row, ST_Value(rast, 2, i, j) As origval,
ST_Value(reclass_rast, 2, i, j) As reclassval,
ST_Value(reclass_rast, 2, i, j, false) As reclassval_include_nodata
FROM dummy_rast CROSS JOIN generate_series(1, 3) AS i CROSS JOIN generate_series(1, 3) AS j
WHERE rid = 2;col | row | origval | reclassval | reclassval_include_nodata -----+-----+---------+------------+--------------------------- 1 | 1 | 78 | 9 | 9 2 | 1 | 98 | 14 | 14 3 | 1 | 122 | | 0 1 | 2 | 96 | 14 | 14 2 | 2 | 118 | | 0 3 | 2 | 180 | | 0 1 | 3 | 99 | 15 | 15 2 | 3 | 112 | | 0 3 | 3 | 169 | | 0
Advanced using multiple reclassargs.
Skapa ett nytt raster från originalet där band 1,2,3 konverteras till 1BB,4BUI, 4BUI respektive och omklassificeras. Observera att detta använder det variadiska reclassarg-argumentet som kan ta ett obegränsat antal reclassargs som indata (teoretiskt sett så många band som du har)
UPDATE dummy_rast SET reclass_rast =
ST_Reclass(
rast,
ROW(2, '0-87]:1-10, (87-100]:11-15, (101-254]:0-0', '4BUI', NULL)::reclassarg,
ROW(1, '0-253]:1, 254:0', '1BB', NULL)::reclassarg,
ROW(3, '0-70]:1, (70-86:2, [86-150):3, [150-255:4', '4BUI', NULL)::reclassarg
) WHERE rid = 2;
SELECT i as col, j as row, ST_Value(rast, 1, i, j) As ov1, ST_Value(reclass_rast, 1, i, j) As rv1,
ST_Value(rast, 2, i, j) As ov2, ST_Value(reclass_rast, 2, i, j) As rv2,
ST_Value(rast, 3, i, j) As ov3, ST_Value(reclass_rast, 3, i, j) As rv3
FROM dummy_rast CROSS JOIN generate_series(1, 3) AS i CROSS JOIN generate_series(1, 3) AS j
WHERE rid = 2;col | row | ov1 | rv1 | ov2 | rv2 | ov3 | rv3 ----+-----+-----+-----+-----+-----+-----+----- 1 | 1 | 253 | 1 | 78 | 9 | 70 | 1 2 | 1 | 254 | 0 | 98 | 14 | 86 | 3 3 | 1 | 253 | 1 | 122 | 0 | 100 | 3 1 | 2 | 253 | 1 | 96 | 14 | 80 | 2 2 | 2 | 254 | 0 | 118 | 0 | 108 | 3 3 | 2 | 254 | 0 | 180 | 0 | 162 | 4 1 | 3 | 250 | 1 | 99 | 15 | 90 | 3 2 | 3 | 254 | 0 | 112 | 0 | 108 | 3 3 | 3 | 254 | 0 | 169 | 0 | 175 | 4
Advanced Map a single band 32BF raster to multiple viewable bands.
Skapa ett nytt 3-bands (8BUI,8BUI,8BUI synligt raster) från ett raster som bara har ett 32bf-band
ALTER TABLE wind ADD COLUMN rast_view raster;
UPDATE wind
set rast_view = ST_AddBand(
NULL,
ARRAY[
ST_Reclass(rast, 1, '0.1-10]:1-10,9-10]:11,(11-33:0'::text, '8BUI'::text, 0),
ST_Reclass(rast, 1, '11-33):0-255,[0-32:0,(34-1000:0'::text, '8BUI'::text, 0),
ST_Reclass(rast, 1, '0-32]:0,(32-100:100-255'::text, '8BUI'::text, 0)
]
);
ST_ReclassExact — Skapar ett nytt raster som består av band som omklassificerats från originalbandet med hjälp av en 1:1-mappning från värden i originalbandet till nya värden i destinationsbandet.
raster ST_ReclassExact(raster rast, double precision[] inputvalues, double precision[] outputvalues, integer bandnumber=1, text pixeltype=32BF, double precision nodatavalue=NULL);
Skapar ett nytt raster som bildas genom att tillämpa en omklassificeringsoperation som definieras av matriserna inputvalues och outputvalues. Pixelvärden som finns i input-arrayen mappas till motsvarande värde i output-arrayen. Alla andra pixelvärden mappas till nodatavärdet.
Pixeltypen för utdata är som standard float, men kan specificeras med hjälp av parametern pixeltype. Om inget bandnumber anges antas band 1.
Det nya rastret kommer att ha samma georeferens, bredd och höjd som det ursprungliga rastret. Band som inte anges returneras oförändrade.
Tillgänglighet: 3.6.0
Skapa ett litet raster och mappa dess pixlar till nya värden.
Create a raster with four pixels: first row 1 2, second row 3 4.
CREATE TABLE reclassexact (
id integer,
rast raster
);
INSERT INTO reclassexact (id, rast)
SELECT 1, ST_SetValues(ST_AddBand(ST_MakeEmptyRaster(2, -- width in pixels
2, -- height in pixels
0, -- upper-left x-coordinate
0, -- upper-left y-coordinate
1, -- pixel size in x-direction
-1, -- pixel size in y-direction (negative for north-up)
0, -- skew in x-direction
0, -- skew in y-direction
4326 -- SRID (e.g., WGS 84)
),
'32BUI'::text, -- pixel type (e.g., '32BF' for float, '8BUI' for unsigned 8-bit int)
0.0, -- initial value for the band (e.g., 0.0 or a no-data value)
-99 -- nodatavalue
),
1, -- band number (usually 1 for single-band rasters)
1, -- x origin for setting values (usually 1)
1, -- y origin for setting values (usually 1)
ARRAY[
ARRAY[1, 2],
ARRAY[3, 4]
]::double precision[][] -- 2D array of values
);
Reclass the values to new values and dump the values of the new raster for display.
WITH rc AS (
SELECT ST_ReclassExact(rast, -- input raster
ARRAY[4, 3, 2, 1], -- input map
ARRAY[14, 13, 12, 11], -- output map
1, -- band number to remap
'32BUI' -- output raster pixel type
) AS rast
FROM reclassexact
WHERE id = 1
)
SELECT 'rce-1', (ST_DumpValues(rc.rast)).*
FROM rc;
ST_Union — Returnerar sammanslagningen av en uppsättning rasterplattor till ett enda raster som består av 1 eller flera band.
raster ST_Union(setof raster rast);
raster ST_Union(setof raster rast, unionarg[] unionargset);
raster ST_Union(setof raster rast, integer nband);
raster ST_Union(setof raster rast, text uniontype);
raster ST_Union(setof raster rast, integer nband, text uniontype);
Returnerar sammanslagningen av en uppsättning rasterplattor till ett enda raster som består av minst ett band. Det resulterande rastrets utsträckning är hela uppsättningens utsträckning. Vid intersektion definieras det resulterande värdet av uniontype, som är något av följande: LAST (standard), FIRST, MIN, MAX, COUNT, SUM, MEAN, RANGE.
![]() | |
För att rasters ska kunna sammanfogas måste de alla ha samma inriktning. Använd ST_SameAlignment och ST_NotSameAlignmentReason för mer information och hjälp. Ett sätt att åtgärda problem med alignment är att använda ST_Resample och använda samma referensraster för alignment. |
Tillgänglighet: 2.0.0
Förbättrad: 2.1.0 Förbättrad hastighet (helt C-baserad).
Tillgänglighet: 2.1.0 Varianten ST_Union(rast, unionarg) introducerades.
Förbättrad: 2.1.0 ST_Union(rast) (variant 1) förenar alla band i alla ingående raster. Tidigare versioner av PostGIS antog det första bandet.
Förbättrad: 2.1.0 ST_Union(rast, uniontype) (variant 4) förenar alla band i alla ingående raster.
Reconstitute a single band chunked raster tile.
This creates a single band from first band of raster tiles. That form the original file system tile.
SELECT filename, ST_Union(rast, 1) As file_rast
FROM sometable WHERE filename IN('dem01', 'dem02') GROUP BY filename;
Return a multi-band raster that is the union of tiles intersecting geometry.
This creates a multi band raster collecting all the tiles that intersect a line. Note that In 2.0, this would have just returned a single band raster. , new union works on all bands by default. This is equivalent to unionarg: ARRAY[ROW(1, 'LAST'), ROW(2, 'LAST'), ROW(3, 'LAST')]::unionarg[].
SELECT ST_Union(rast)
FROM aerials.boston
WHERE ST_Intersects(rast, ST_GeomFromText('LINESTRING(230486 887771,230500 88772)', 26986) );
Select and reorder bands while unioning tiles that intersect a geometry.
Här använder vi den längre syntaxen om vi bara vill ha en delmängd av banden eller om vi vill ändra ordningen på banden
This creates a multi band raster collecting all the tiles that intersect a line.
SELECT ST_Union(rast, ARRAY[ROW(2, 'LAST'), ROW(1, 'LAST'), ROW(3, 'LAST')]::unionarg[])
FROM aerials.boston
WHERE ST_Intersects(rast, ST_GeomFromText('LINESTRING(230486 887771,230500 88772)', 26986) );
ST_Distinct4ma — Rasterbearbetningsfunktion som beräknar antalet unika pixelvärden i ett grannskap.
float8 ST_Distinct4ma(float8[][] matrix, text nodatamode, text[] VARIADIC args);
double precision ST_Distinct4ma(double precision[][][] value, integer[][] pos, text[] VARIADIC userargs);
Beräkna antalet unika pixelvärden i ett grannskap av pixlar.
![]() | |
Variant 1 är en specialiserad återuppringningsfunktion för användning som återuppringningsparameter till ST_MapAlgebraFctNgb. |
![]() | |
Variant 2 är en specialiserad återuppringningsfunktion för användning som återuppringningsparameter till ST_MapAlgebra (callback function version). |
![]() | |
Användning av variant 1 avråds eftersom ST_MapAlgebraFctNgb har utgått från och med 2.1.0. |
Tillgänglighet: 2.0.0
Förbättrad: 2.1.0 Tillägg av variant 2
SELECT
rid,
ST_Value(ST_MapAlgebraFctNgb(rast, 1, NULL, 1, 1, 'ST_Distinct4ma(float[][],text,text[])'::regprocedure, 'ignore', NULL), 2, 2
)
FROM dummy_rast
WHERE rid = 2;rid | st_value -----+---------- 2 | 3 (1 row)
ST_InvDistWeight4ma — Rasterbearbetningsfunktion som interpolerar en pixels värde från pixelns närområde.
double precision ST_InvDistWeight4ma(double precision[][][] value, integer[][] pos, text[] VARIADIC userargs);
Beräkna ett interpolerat värde för en pixel med hjälp av den omvända avståndsviktade metoden.
Det finns två valfria parametrar som kan skickas via userargs. Den första parametern är den effektfaktor (variabel k i ekvationen nedan) mellan 0 och 1 som används i den inversa avståndsviktade ekvationen. Om den inte anges är standardvärdet 1. Den andra parametern är den viktprocent som endast tillämpas när värdet för den intressanta pixeln ingår i det interpolerade värdet från grannskapet. Om inget anges och den intressanta pixeln har ett värde, returneras detta värde.
The basic inverse-distance weighted estimate is:
Here zᵢ is a neighboring pixel value, dᵢ is its distance from the pixel being estimated, and k is a real-valued power factor between 0 and 1.
![]() | |
Denna funktion är en specialiserad återuppringningsfunktion för användning som återuppringningsparameter till ST_MapAlgebra (callback function version). |
Tillgänglighet: 2.1.0
WITH foo AS (
SELECT ST_SetValues(ST_AddBand(ST_MakeEmptyRaster(3, 3, 0, 0, 1, -1, 0, 0, 0), 1, '32BF', NULL::double precision, -9999),
1, 1, 1, ARRAY[
[10, 10, 10],
[10, NULL, 20],
[20, 20, 20]
]::double precision[][]
) AS rast
)
SELECT ST_Value(
ST_MapAlgebra(
rast,
1,
'ST_InvDistWeight4ma(double precision[][][],integer[][],text[])'::regprocedure,
'32BF',
'FIRST',
NULL,
1,
1
),
2, 2
) AS interpolated_value
FROM foo;15
ST_Max4ma — Rasterbearbetningsfunktion som beräknar det maximala pixelvärdet i ett grannskap.
float8 ST_Max4ma(float8[][] matrix, text nodatamode, text[] VARIADIC args);
double precision ST_Max4ma(double precision[][][] value, integer[][] pos, text[] VARIADIC userargs);
Beräkna det maximala pixelvärdet i ett grannskap av pixlar.
För variant 2 kan ett ersättningsvärde för NODATA-pixlar anges genom att skicka det värdet till userargs.
![]() | |
Variant 1 är en specialiserad återuppringningsfunktion för användning som återuppringningsparameter till ST_MapAlgebraFctNgb. |
![]() | |
Variant 2 är en specialiserad återuppringningsfunktion för användning som återuppringningsparameter till ST_MapAlgebra (callback function version). |
![]() | |
Användning av variant 1 avråds eftersom ST_MapAlgebraFctNgb har utgått från och med 2.1.0. |
Tillgänglighet: 2.0.0
Förbättrad: 2.1.0 Tillägg av variant 2
SELECT
rid,
ST_Value(ST_MapAlgebraFctNgb(rast, 1, NULL, 1, 1, 'ST_Max4ma(float[][],text,text[])'::regprocedure, 'ignore', NULL), 2, 2
)
FROM dummy_rast
WHERE rid = 2;rid | st_value -----+---------- 2 | 254 (1 row)
ST_Mean4ma — Rasterbearbetningsfunktion som beräknar det genomsnittliga pixelvärdet i ett grannskap.
float8 ST_Mean4ma(float8[][] matrix, text nodatamode, text[] VARIADIC args);
double precision ST_Mean4ma(double precision[][][] value, integer[][] pos, text[] VARIADIC userargs);
Beräkna det genomsnittliga pixelvärdet i ett grannskap av pixlar.
För variant 2 kan ett ersättningsvärde för NODATA-pixlar anges genom att skicka det värdet till userargs.
![]() | |
Variant 1 är en specialiserad återuppringningsfunktion för användning som återuppringningsparameter till ST_MapAlgebraFctNgb. |
![]() | |
Variant 2 är en specialiserad återuppringningsfunktion för användning som återuppringningsparameter till ST_MapAlgebra (callback function version). |
![]() | |
Användning av variant 1 avråds eftersom ST_MapAlgebraFctNgb har utgått från och med 2.1.0. |
Tillgänglighet: 2.0.0
Förbättrad: 2.1.0 Tillägg av variant 2
Variant 1.
SELECT
rid,
ST_Value(ST_MapAlgebraFctNgb(rast, 1, '32BF', 1, 1, 'ST_Mean4ma(float[][],text,text[])'::regprocedure, 'ignore', NULL), 2, 2
)
FROM dummy_rast
WHERE rid = 2;rid | st_value -----+------------------ 2 | 253.222229003906 (1 row)
Variant 2.
SELECT
rid,
ST_Value(
ST_MapAlgebra(rast, 1, 'ST_Mean4ma(double precision[][][], integer[][], text[])'::regprocedure, '32BF', 'FIRST', NULL, 1, 1),
2,
2)
FROM dummy_rast
WHERE rid = 2;rid | st_value -----+------------------ 2 | 253.222229003906 (1 row)
ST_Min4ma — Rasterbearbetningsfunktion som beräknar det lägsta pixelvärdet i ett grannskap.
float8 ST_Min4ma(float8[][] matrix, text nodatamode, text[] VARIADIC args);
double precision ST_Min4ma(double precision[][][] value, integer[][] pos, text[] VARIADIC userargs);
Beräkna det lägsta pixelvärdet i ett grannskap av pixlar.
För variant 2 kan ett ersättningsvärde för NODATA-pixlar anges genom att skicka det värdet till userargs.
![]() | |
Variant 1 är en specialiserad återuppringningsfunktion för användning som återuppringningsparameter till ST_MapAlgebraFctNgb. |
![]() | |
Variant 2 är en specialiserad återuppringningsfunktion för användning som återuppringningsparameter till ST_MapAlgebra (callback function version). |
![]() | |
Användning av variant 1 avråds eftersom ST_MapAlgebraFctNgb har utgått från och med 2.1.0. |
Tillgänglighet: 2.0.0
Förbättrad: 2.1.0 Tillägg av variant 2
SELECT
rid,
ST_Value(ST_MapAlgebraFctNgb(rast, 1, NULL, 1, 1, 'ST_Min4ma(float[][],text,text[])'::regprocedure, 'ignore', NULL), 2, 2
)
FROM dummy_rast
WHERE rid = 2;rid | st_value -----+---------- 2 | 250 (1 row)
ST_MinDist4ma — Rasterbehandlingsfunktion som returnerar det minsta avståndet (i antal pixlar) mellan den intressanta pixeln och en angränsande pixel med värde.
double precision ST_MinDist4ma(double precision[][][] value, integer[][] pos, text[] VARIADIC userargs);
Returnerar det kortaste avståndet (i antal pixlar) mellan den intressanta pixeln och den närmaste pixeln med värde i grannskapet.
![]() | |
Syftet med den här funktionen är att tillhandahålla en informativ datapunkt som hjälper till att dra slutsatser om användbarheten av den intressanta pixelns interpolerade värde från ST_InvDistWeight4ma. Den här funktionen är särskilt användbar när grannskapet är glest befolkat. |
![]() | |
Denna funktion är en specialiserad återuppringningsfunktion för användning som återuppringningsparameter till ST_MapAlgebra (callback function version). |
Tillgänglighet: 2.1.0
WITH foo AS (
SELECT ST_SetValues(ST_AddBand(ST_MakeEmptyRaster(3, 3, 0, 0, 1, -1, 0, 0, 0), 1, '32BF', NULL::double precision, -9999),
1, 1, 1, ARRAY[
[10, 10, 10],
[10, NULL, 20],
[20, 20, 20]
]::double precision[][]
) AS rast
)
SELECT ST_Value(
ST_MapAlgebra(
rast,
1,
'ST_MinDist4ma(double precision[][][],integer[][],text[])'::regprocedure,
'32BF',
'FIRST',
NULL,
1,
1
),
2, 2
) AS min_distance
FROM foo;1
ST_Range4ma — Rasterbearbetningsfunktion som beräknar intervallet för pixelvärden i ett område.
float8 ST_Range4ma(float8[][] matrix, text nodatamode, text[] VARIADIC args);
double precision ST_Range4ma(double precision[][][] value, integer[][] pos, text[] VARIADIC userargs);
Beräkna intervallet av pixelvärden i ett grannskap av pixlar.
För variant 2 kan ett ersättningsvärde för NODATA-pixlar anges genom att skicka det värdet till userargs.
![]() | |
Variant 1 är en specialiserad återuppringningsfunktion för användning som återuppringningsparameter till ST_MapAlgebraFctNgb. |
![]() | |
Variant 2 är en specialiserad återuppringningsfunktion för användning som återuppringningsparameter till ST_MapAlgebra (callback function version). |
![]() | |
Användning av variant 1 avråds eftersom ST_MapAlgebraFctNgb har utgått från och med 2.1.0. |
Tillgänglighet: 2.0.0
Förbättrad: 2.1.0 Tillägg av variant 2
SELECT
rid,
ST_Value(ST_MapAlgebraFctNgb(rast, 1, NULL, 1, 1, 'ST_Range4ma(float[][],text,text[])'::regprocedure, 'ignore', NULL), 2, 2
)
FROM dummy_rast
WHERE rid = 2;rid | st_value -----+---------- 2 | 4 (1 row)
ST_StdDev4ma — Rasterbearbetningsfunktion som beräknar standardavvikelsen för pixelvärden i ett grannskap.
float8 ST_StdDev4ma(float8[][] matrix, text nodatamode, text[] VARIADIC args);
double precision ST_StdDev4ma(double precision[][][] value, integer[][] pos, text[] VARIADIC userargs);
Beräkna standardavvikelsen för pixelvärden i ett grannskap av pixlar.
![]() | |
Variant 1 är en specialiserad återuppringningsfunktion för användning som återuppringningsparameter till ST_MapAlgebraFctNgb. |
![]() | |
Variant 2 är en specialiserad återuppringningsfunktion för användning som återuppringningsparameter till ST_MapAlgebra (callback function version). |
![]() | |
Användning av variant 1 avråds eftersom ST_MapAlgebraFctNgb har utgått från och med 2.1.0. |
Tillgänglighet: 2.0.0
Förbättrad: 2.1.0 Tillägg av variant 2
SELECT
rid,
ST_Value(ST_MapAlgebraFctNgb(rast, 1, '32BF', 1, 1, 'ST_StdDev4ma(float[][],text,text[])'::regprocedure, 'ignore', NULL), 2, 2
)
FROM dummy_rast
WHERE rid = 2;rid | st_value -----+------------------ 2 | 1.30170822143555 (1 row)
ST_Sum4ma — Rasterbearbetningsfunktion som beräknar summan av alla pixelvärden i ett grannskap.
float8 ST_Sum4ma(float8[][] matrix, text nodatamode, text[] VARIADIC args);
double precision ST_Sum4ma(double precision[][][] value, integer[][] pos, text[] VARIADIC userargs);
Beräkna summan av alla pixelvärden i ett grannskap av pixlar.
För variant 2 kan ett ersättningsvärde för NODATA-pixlar anges genom att skicka det värdet till userargs.
![]() | |
Variant 1 är en specialiserad återuppringningsfunktion för användning som återuppringningsparameter till ST_MapAlgebraFctNgb. |
![]() | |
Variant 2 är en specialiserad återuppringningsfunktion för användning som återuppringningsparameter till ST_MapAlgebra (callback function version). |
![]() | |
Användning av variant 1 avråds eftersom ST_MapAlgebraFctNgb har utgått från och med 2.1.0. |
Tillgänglighet: 2.0.0
Förbättrad: 2.1.0 Tillägg av variant 2
SELECT
rid,
ST_Value(ST_MapAlgebraFctNgb(rast, 1, '32BF', 1, 1, 'ST_Sum4ma(float[][],text,text[])'::regprocedure, 'ignore', NULL), 2, 2
)
FROM dummy_rast
WHERE rid = 2;rid | st_value -----+---------- 2 | 2279 (1 row)
ST_Aspect — Returnerar aspekten (i grader som standard) för ett höjdrasterband. Användbart för analys av terräng.
raster ST_Aspect(raster rast, integer band=1, text pixeltype=32BF, text units=DEGREES, boolean interpolate_nodata=FALSE);
raster ST_Aspect(raster rast, integer band, raster customextent, text pixeltype=32BF, text units=DEGREES, boolean interpolate_nodata=FALSE);
Returnerar aspekten (i grader som standard) för ett höjdrasterband. Utnyttjar kartalgebra och tillämpar aspektekvationen på närliggande pixlar.
units anger enheten för aspekten. Möjliga värden är: RADIANS, DEGREES (standard).
När units = RADIANS är värdena mellan 0 och 2 * pi radianer mätt medurs från norr.
När units = DEGREES är värdena mellan 0 och 360 grader mätt medurs från norr.
Om pixelns lutning är noll är pixelns aspekt -1.
![]() | |
Mer information om Slope, Aspect och Hillshade finns i ESRI - How hillshade works och ERDAS Field Guide - Aspect Images. |
Tillgänglighet: 2.0.0
Förbättrad: 2.1.0 Använder ST_MapAlgebra() och har lagt till en valfri funktionsparameter för interpolate_nodata
Ändrad: 2.1.0 I tidigare versioner var returvärdena i radianer. Nu är returvärdena som standard grader
Variant 1.
This symmetric peak highlights the expected compass directions at the corners and the -1 aspect at the summit. The generated PNG shows the full aspect surface without relying on a manual illustration. The generated source raster is large enough for the PNG to show the directional field around the summit.
WITH pixels AS (
SELECT
x,
y,
(20 - greatest(abs(x - 9), abs(y - 9)))::double precision AS value
FROM generate_series(1, 17) AS y
CROSS JOIN generate_series(1, 17) AS x
), rows AS (
SELECT
y,
array_agg(value ORDER BY x) AS row_values
FROM pixels
GROUP BY y
), source AS (
SELECT ST_SetValues(
ST_AddBand(
ST_MakeEmptyRaster(17, 17, 0, 0, 1, -1, 0, 0, 0),
1, '32BF', 0, -9999
),
1, 1, 1,
array_agg(row_values ORDER BY y)::double precision[][]
) AS rast
FROM rows
), aspect AS (
SELECT ST_Aspect(rast, 1, '32BF') AS rast
FROM source
)
SELECT
round(ST_Value(rast, 1, 1, 1)::numeric, 3) AS northwest_degrees,
round(ST_Value(rast, 1, 9, 9)::numeric, 3) AS summit_degrees,
round(ST_Value(rast, 1, 17, 17)::numeric, 3) AS southeast_degrees,
ST_AsPNG(ST_ColorMap(rast, 1, 'bluered')) AS image
FROM aspect;northwest_degrees | summit_degrees | southeast_degrees | image
-------------------+----------------+-------------------+------------------------
315.000 | -1.000 | 135.000 | PNG image, 17 x 17 pixelsVariant 2.
Complete example of tiles of a coverage.
WITH foo AS (
SELECT ST_Tile(ST_SetValues(ST_AddBand(ST_MakeEmptyRaster(6, 6, 0, 0, 1, -1, 0, 0, 0),
1, '32BF', 0, -9999
),
1, 1, 1, ARRAY[
[1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 2, 1],
[1, 2, 2, 3, 3, 1],
[1, 1, 3, 2, 1, 1],
[1, 2, 2, 1, 2, 1],
[1, 1, 1, 1, 1, 1]
]::double precision[]
),
2, 2
) AS rast
)
SELECT
t1.rast,
ST_Aspect(ST_Union(t2.rast), 1, t1.rast)
FROM foo t1
CROSS JOIN foo t2
WHERE ST_Intersects(t1.rast, t2.rast)
GROUP BY t1.rast;
ST_HillShade — Returnerar den hypotetiska belysningen för ett höjdrasterband med hjälp av angivna indata för azimut, höjd, ljusstyrka och skala.
raster ST_HillShade(raster rast, integer band=1, text pixeltype=32BF, double precision azimuth=315, double precision altitude=45, double precision max_bright=255, double precision scale=1.0, boolean interpolate_nodata=FALSE);
raster ST_HillShade(raster rast, integer band, raster customextent, text pixeltype=32BF, double precision azimuth=315, double precision altitude=45, double precision max_bright=255, double precision scale=1.0, boolean interpolate_nodata=FALSE);
Returnerar den hypotetiska belysningen av ett höjdrasterband med hjälp av indatavärdena azimut, höjd, ljusstyrka och skala. Använder kartalgebra och tillämpar ekvationen för kullskugga på närliggande pixlar. Returpixelvärdena ligger mellan 0 och 255.
azimut är ett värde mellan 0 och 360 grader mätt medurs från norr.
höjden är ett värde mellan 0 och 90 grader där 0 grader är vid horisonten och 90 grader är rakt ovanför.
max_bright är ett värde mellan 0 och 255 med 0 som ingen ljusstyrka och 255 som maximal ljusstyrka.
skala är förhållandet mellan vertikala enheter och horisontella. För Feet:LatLon används scale=370400, för Meter:LatLon används scale=111120.
Om interpolate_nodata är TRUE interpoleras värdena för NODATA-pixlar från indatarastret med ST_InvDistWeight4ma innan belysningen för hillshade beräknas.
![]() | |
Mer information om Hillshade finns i avsnittet Så fungerar Hillshade. |
Tillgänglighet: 2.0.0
Förbättrad: 2.1.0 Använder ST_MapAlgebra() och har lagt till en valfri funktionsparameter för interpolate_nodata
Ändrad: 2.1.0 I tidigare versioner uttrycktes azimut och höjd i radianer. Nu uttrycks azimut och höjd i grader
Variant 1.
WITH foo AS (
SELECT ST_SetValues(ST_AddBand(ST_MakeEmptyRaster(5, 5, 0, 0, 1, -1, 0, 0, 0), 1, '32BF', 0, -9999),
1, 1, 1, ARRAY[
[1, 1, 1, 1, 1],
[1, 2, 2, 2, 1],
[1, 2, 3, 2, 1],
[1, 2, 2, 2, 1],
[1, 1, 1, 1, 1]
]::double precision[][]
) AS rast
)
SELECT
ST_DumpValues(ST_HillShade(rast, 1, '32BF'))
FROM foo
st_dumpvalues------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-----------------------------------------------------------------------
(1,"{{NULL,NULL,NULL,NULL,NULL},{NULL,251.32763671875,220.749786376953,147.224319458008,NULL},{NULL,220.749786376953,180.312225341797,67.7497863769531,NULL},{NULL,147.224319458008,
67.7497863769531,43.1210060119629,NULL},{NULL,NULL,NULL,NULL,NULL}}")
(1 row)Variant 2.
Complete example of tiles of a coverage.
WITH foo AS (
SELECT ST_Tile(ST_SetValues(ST_AddBand(ST_MakeEmptyRaster(6, 6, 0, 0, 1, -1, 0, 0, 0),
1, '32BF', 0, -9999
),
1, 1, 1, ARRAY[
[1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 2, 1],
[1, 2, 2, 3, 3, 1],
[1, 1, 3, 2, 1, 1],
[1, 2, 2, 1, 2, 1],
[1, 1, 1, 1, 1, 1]
]::double precision[]
),
2, 2
) AS rast
)
SELECT
t1.rast,
ST_HillShade(ST_Union(t2.rast), 1, t1.rast)
FROM foo t1
CROSS JOIN foo t2
WHERE ST_Intersects(t1.rast, t2.rast)
GROUP BY t1.rast;
ST_Roughness — Returnerar ett raster med den beräknade "ojämnheten" för en DEM.
raster ST_Roughness(raster rast, integer nband, raster customextent, text pixeltype="32BF" , boolean interpolate_nodata=FALSE );
Beräknar "grovheten" i en DEM genom att subtrahera maximum från minimum för ett visst område.
Tillgänglighet: 2.1.0
WITH foo AS (
SELECT ST_SetValues(ST_AddBand(ST_MakeEmptyRaster(5, 5, 0, 0, 1, -1, 0, 0, 0), 1, '32BF', 0, -9999),
1, 1, 1, ARRAY[
[1, 1, 2, 3, 3],
[1, 2, 4, 15, 3],
[2, 4, 10, 7, 5],
[3, 5, 7, 6, 4],
[3, 3, 5, 4, 4]
]::double precision[][]
) AS rast
)
SELECT ST_Value(ST_Roughness(rast, 1, '32BF'), 3, 3) AS roughness
FROM foo;13
ST_Slope — Returnerar lutningen (i grader som standard) för ett höjdrasterband. Användbart för att analysera terräng.
raster ST_Slope(raster rast, integer nband=1, text pixeltype=32BF, text units=DEGREES, double precision scale=1.0, boolean interpolate_nodata=FALSE);
raster ST_Slope(raster rast, integer nband, raster customextent, text pixeltype=32BF, text units=DEGREES, double precision scale=1.0, boolean interpolate_nodata=FALSE);
Returnerar lutningen (i grader som standard) för ett höjdrasterband. Utnyttjar kartalgebra och tillämpar lutningsekvationen på angränsande pixlar.
units anger enheten för lutningen. Möjliga värden är: RADIANS, DEGREES (standard), PERCENT.
skala är förhållandet mellan vertikala enheter och horisontella. För Feet:LatLon används scale=370400, för Meter:LatLon används scale=111120.
Om interpolate_nodata är TRUE interpoleras värden för NODATA-pixlar från indatarastret med ST_InvDistWeight4ma innan ytans lutning beräknas.
![]() | |
Mer information om Slope, Aspect och Hillshade finns i ESRI - How hillshade works och ERDAS Field Guide - Slope Images. |
Tillgänglighet: 2.0.0
Förbättrad: 2.1.0 Använder ST_MapAlgebra() och har lagt till valfria funktionsparametrar för units, scale, interpolate_nodata
Ändrad: 2.1.0 I tidigare versioner var returvärdena i radianer. Nu är returvärdena som standard grader
Variant 1.
WITH foo AS (
SELECT ST_SetValues(ST_AddBand(ST_MakeEmptyRaster(5, 5, 0, 0, 1, -1, 0, 0, 0), 1, '32BF', 0, -9999),
1, 1, 1, ARRAY[
[1, 1, 1, 1, 1],
[1, 2, 2, 2, 1],
[1, 2, 3, 2, 1],
[1, 2, 2, 2, 1],
[1, 1, 1, 1, 1]
]::double precision[][]
) AS rast
)
SELECT
ST_DumpValues(ST_Slope(rast, 1, '32BF'))
FROM foo
st_dumpvalues------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------
(1,"{{10.0249881744385,21.5681285858154,26.5650520324707,21.5681285858154,10.0249881744385},{21.5681285858154,35.2643890380859,36.8698959350586,35.2643890380859,21.5681285858154},
{26.5650520324707,36.8698959350586,0,36.8698959350586,26.5650520324707},{21.5681285858154,35.2643890380859,36.8698959350586,35.2643890380859,21.5681285858154},{10.0249881744385,21.
5681285858154,26.5650520324707,21.5681285858154,10.0249881744385}}")
(1 row)Variant 2.
Complete example of tiles of a coverage.
WITH foo AS (
SELECT ST_Tile(ST_SetValues(ST_AddBand(ST_MakeEmptyRaster(6, 6, 0, 0, 1, -1, 0, 0, 0),
1, '32BF', 0, -9999
),
1, 1, 1, ARRAY[
[1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 2, 1],
[1, 2, 2, 3, 3, 1],
[1, 1, 3, 2, 1, 1],
[1, 2, 2, 1, 2, 1],
[1, 1, 1, 1, 1, 1]
]::double precision[]
),
2, 2
) AS rast
)
SELECT
t1.rast,
ST_Slope(ST_Union(t2.rast), 1, t1.rast)
FROM foo t1
CROSS JOIN foo t2
WHERE ST_Intersects(t1.rast, t2.rast)
GROUP BY t1.rast;
ST_TPI — Returnerar ett raster med det beräknade topografiska positionsindexet.
raster ST_TPI(raster rast, integer nband, raster customextent, text pixeltype="32BF" , boolean interpolate_nodata=FALSE );
Beräknar det topografiska positionsindexet, som definieras som det fokala medelvärdet med radien ett minus den centrala cellen.
![]() | |
Denna funktion stöder endast en fokal medelradie på ett. |
Tillgänglighet: 2.1.0
WITH foo AS (
SELECT ST_SetValues(ST_AddBand(ST_MakeEmptyRaster(5, 5, 0, 0, 1, -1, 0, 0, 0), 1, '32BF', 0, -9999),
1, 1, 1, ARRAY[
[1, 1, 2, 3, 3],
[1, 2, 4, 15, 3],
[2, 4, 10, 7, 5],
[3, 5, 7, 6, 4],
[3, 3, 5, 4, 4]
]::double precision[][]
) AS rast
)
SELECT ST_Value(ST_TPI(rast, 1, '32BF'), 3, 3) AS tpi
FROM foo;3.75
ST_TRI — Returnerar ett raster med det beräknade Terrain Ruggedness Index.
raster ST_TRI(raster rast, integer nband, raster customextent, text pixeltype="32BF" , boolean interpolate_nodata=FALSE );
Terrain Ruggedness Index beräknas genom att jämföra en central pixel med dess grannar, ta de absoluta värdena av skillnaderna och beräkna medelvärdet av resultatet.
![]() | |
Denna funktion stöder endast en fokal medelradie på ett. |
Tillgänglighet: 2.1.0
WITH foo AS (
SELECT ST_SetValues(ST_AddBand(ST_MakeEmptyRaster(5, 5, 0, 0, 1, -1, 0, 0, 0), 1, '32BF', 0, -9999),
1, 1, 1, ARRAY[
[1, 1, 2, 3, 3],
[1, 2, 4, 15, 3],
[2, 4, 10, 7, 5],
[3, 5, 7, 6, 4],
[3, 3, 5, 4, 4]
]::double precision[][]
) AS rast
)
SELECT ST_Value(ST_TRI(rast, 1, '32BF'), 3, 3) AS tri
FROM foo;5
ST_InterpolateRaster — Interpolerar en rutnätsyta baserat på en indatauppsättning av 3D-punkter, med hjälp av X- och Y-värdena för att positionera punkterna i rutnätet och punkternas Z-värde som ytans höjd.
raster ST_InterpolateRaster(geometry input_points, text algorithm_options, raster template, integer template_band_num=1);
Interpolerar en yta i rutnät baserat på en indatauppsättning med 3D-punkter, med hjälp av X- och Y-värdena för att positionera punkterna i rutnätet och punkternas Z-värde som ytans höjd. Det finns fem interpolationsalgoritmer tillgängliga: invers avstånd, invers avstånd närmaste granne, glidande medelvärde, närmaste granne och linjär interpolation. Se dokumentationen för gdal_grid för mer information om algoritmerna och deras parametrar. Mer information om hur interpoleringar beräknas finns i GDAL Grid Tutorial.
Inmatningsparametrar är:
input_pointsDe punkter som ska driva interpoleringen. Alla geometrier med Z-värden är acceptabla, alla punkter i indata kommer att användas.
algorithm_optionsEn sträng som definierar algoritmen och algoritmalternativen, i det format som används av gdal_grid. Om du t.ex. vill göra en interpolering med omvänt avstånd och en utjämning på 2 använder du "invdist:smoothing=2.0"
templateEn rastermall för att styra geometrin i utdatarastret. Bredd, höjd, pixelstorlek, spatial utsträckning och pixeltyp kommer att läsas från denna mall.
template_band_numSom standard används det första bandet i mallrastret för att driva utdatarastret, men det kan justeras med den här parametern.
Tillgänglighet: 3.2.0
SELECT ST_InterpolateRaster('MULTIPOINT(10.5 9.5 1000,11.5 8.5 1000,10.5 8.5 500,11.5 9.5 500)'::geometry,
'invdist:smoothing:2.0',
ST_AddBand(ST_MakeEmptyRaster(200, 400, 10, 10, 0.01, -0.005, 0, 0), '16BSI')
)ST_Contour — Skapar en uppsättning vektorkonturer från det tillhandahållna rasterbandet med hjälp av GDAL-konturalgoritmen.
setof record ST_Contour(raster rast, integer bandnumber=1, double precision level_interval=100.0, double precision level_base=0.0, double precision[] fixed_levels=ARRAY[], boolean polygonize=false);
Skapar en uppsättning vektorkonturer från det tillhandahållna rasterbandet med hjälp av GDAL-konturalgoritmen.
När parametern fixed_levels är en icke-tom array ignoreras parametrarna level_interval och level_base.
Inmatningsparametrar är:
rastRastret för att generera konturen av
bandnumberBandet för att generera konturen av
level_intervalHöjdintervallet mellan genererade konturer
level_baseDen "bas" i förhållande till vilken konturintervallen tillämpas, normalt noll, men kan vara annorlunda. För att generera konturer på 10 m vid 5, 15, 25, ... skulle LEVEL_BASE vara 5.
fixed_levelsHöjdintervallet mellan genererade konturer
polygonizeOm true, kommer konturpolygoner att skapas i stället för polygonlinjer.
Returvärdena är en uppsättning poster med följande attribut:
geomKonturlinjens geometri.
idEn unik identifierare som GDAL ger till konturlinjen.
valueDet rastervärde som linjen representerar. För en höjd-DEM-indata skulle detta vara höjden på den utgående konturen.
Tillgänglighet: 3.2.0
WITH c AS ( SELECT (ST_Contour(rast, 1, fixed_levels => ARRAY[100.0, 200.0, 300.0])).* FROM dem_grid WHERE rid = 1 ) SELECT geom, id, value FROM c;
Box3D — Returnerar box 3d-representationen av den omslutande boxen i rastret.
box3d Box3D(raster rast);
Returnerar den ruta som representerar rastrets utsträckning.
Polygonen definieras av hörnpunkterna i den avgränsande boxen ((MINX, MINY),(MAXX, MAXY))
Ändrad: 2.0.0 I versioner före 2.0 brukade det finnas en box2d istället för box3d. Eftersom box2d är en föråldrad typ ändrades detta till box3d.
SELECT
rid,
Box3D(rast) AS rastbox
FROM dummy_rast;rid | rastbox ----+------------------------------------------------- 1 | BOX3D(0.5 0.5 0,20.5 60.5 0) 2 | BOX3D(3427927.75 5793243.5 0,3427928 5793244 0)
ST_ConvexHull — Returnerar rastrets konvexa skrovgeometri inklusive pixelvärden som är lika med BandNoDataValue. För regelbundet formade och icke snedställda raster ger detta samma resultat som ST_Envelope, så det är endast användbart för oregelbundet formade eller snedställda raster.
geometry ST_ConvexHull(raster rast);
Returnerar rastrets konvexa skrovgeometri inklusive NoDataBandValue-bandpixlarna. För regelbundet formade och icke-skeva raster ger detta mer eller mindre samma resultat som ST_Envelope, så det är endast användbart för oregelbundet formade eller skeva raster.
![]() | |
ST_Envelope golvar koordinaterna och lägger därför till en liten buffert runt rastret så svaret är subtilt annorlunda än ST_ConvevexHull som inte golvar. |
See doc/development/internals/raster-affine.md for the scale, skew, and rotation terms that make the convex hull and envelope differ for skewed rasters.
For regular non-skewed rasters, the envelope and convex hull are more or less the same.
SELECT ST_ConvexHull(rast) As convhull, ST_Envelope(rast) As env FROM dummy_rast WHERE rid=1;
convhull | env --------------------------------------------------------+------------------------------------ POLYGON((0.5 0.5,20.5 0.5,20.5 60.5,0.5 60.5,0.5 0.5)) | POLYGON((0 0,20 0,20 60,0 60,0 0))
Now we skew the raster. Note how the convex hull and envelope are now different.
SELECT ST_ConvexHull(rast) As convhull, ST_Envelope(rast) As env
FROM (SELECT ST_SetRotation(rast, 0.1, 0.1) As rast
FROM dummy_rast WHERE rid=1) As foo;convhull | env --------------------------------------------------------+------------------------------------ POLYGON((0.5 0.5,20.5 1.5,22.5 61.5,2.5 60.5,0.5 0.5)) | POLYGON((0 0,22 0,22 61,0 61,0 0))
ST_DumpAsPolygons — Returnerar en uppsättning geomval (geom,val)-rader från ett givet rasterband. Om inget bandnummer anges är standardvärdet för bandnum 1.
setof geomval ST_DumpAsPolygons(raster rast, integer band_num=1, boolean exclude_nodata_value=TRUE);
Detta är en SRF-funktion (set-returning function). Den returnerar en uppsättning geomval-rader, som bildas av en geometri (geom) och ett pixelbandvärde (val). Varje polygon är en sammanslagning av alla pixlar för det bandet som har samma pixelvärde som betecknas med val.
ST_DumpAsPolygon är användbar för polygonisering av raster. Det är motsatsen till en GROUP BY eftersom det skapar nya rader. Det kan t.ex. användas för att expandera ett enda raster till flera POLYGONER/MULTIPOLYGONER.
Ändrad 3.3.0, validering och fixering är inaktiverad för att förbättra prestanda. Kan resultera i ogiltiga geometrier.
Changed 3.7.0, the polygonization honours PostgreSQL interrupts so cancellations and statement timeouts halt processing promptly.
Tillgänglighet: Kräver GDAL 1.7 eller högre.
![]() | |
Om ett no data-värde har ställts in för ett band kommer pixlar med det värdet inte att returneras, utom i fallet med exclude_nodata_value=false. |
![]() | |
Om du bara bryr dig om antalet pixlar med ett visst värde i ett raster går det snabbare att använda ST_ValueCount. |
![]() | |
Detta skiljer sig från ST_PixelAsPolygons där en geometri returneras för varje pixel oavsett pixelvärde. |
This syntax uses a LATERAL join.
SELECT val,geom As geomwkt FROM ( SELECT dp.* FROM dummy_rast, LATERAL ST_DumpAsPolygons(rast) AS dp WHERE rid = 2 ) As foo WHERE val BETWEEN 249 and 251 ORDER BY val;
val | geomwkt
-----+--------------------------------------------------------------------------
249 | POLYGON((3427927.95 5793243.95,3427927.95 5793243.85,3427928 5793243.85,
3427928 5793243.95,3427927.95 5793243.95))
250 | POLYGON((3427927.75 5793243.9,3427927.75 5793243.85,3427927.8 5793243.85,
3427927.8 5793243.9,3427927.75 5793243.9))
250 | POLYGON((3427927.8 5793243.8,3427927.8 5793243.75,3427927.85 5793243.75,
3427927.85 5793243.8, 3427927.8 5793243.8))
251 | POLYGON((3427927.75 5793243.85,3427927.75 5793243.8,3427927.8 5793243.8,
3427927.8 5793243.85,3427927.75 5793243.85))geomval, ST_AsRasterAgg, ST_Value, ST_Polygon, ST_ValueCount
ST_Envelope — Returnerar en polygonrepresentation av rastrets utbredning.
geometry ST_Envelope(raster rast);
Returnerar polygonrepresentationen av rastrets utbredning i spatiala koordinatenheter definierade av srid. Det är en float8 minsta avgränsande box som representeras som en polygon.
Polygonen definieras av hörnpunkterna i den begränsande boxen ((MINX, MINY), (MINX, MAXY),(MAXX, MAXY),(MAXX, MINY), (MINX, MINY))
SELECT rid, ST_Envelope(rast) As envgeomwkt FROM dummy_rast;
rid | envgeomwkt
-----+--------------------------------------------------------------------
1 | POLYGON((0 0,20 0,20 60,0 60,0 0))
2 | POLYGON((3427927 5793243,3427928 5793243,
3427928 5793244,3427927 5793244, 3427927 5793243))ST_MinConvexHull — Returnerar rastrets konvexa skrovgeometri exklusive NODATA-pixlar.
geometry ST_MinConvexHull(raster rast, integer nband=NULL);
Returnerar rastrets konvexa skrovgeometri exklusive NODATA-pixlar. Om nband är NULL beaktas alla band i rastret.
Tillgänglighet: 2.1.0
WITH foo AS (
SELECT
ST_SetValues(ST_SetValues(ST_AddBand(ST_AddBand(ST_MakeEmptyRaster(9, 9, 0, 0, 1, -1, 0, 0, 0), 1, '8BUI', 0, 0), 2, '8BUI', 1, 0),
1, 1, 1,
ARRAY[
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 1],
[0, 0, 0, 1, 1, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0]
]::double precision[][]
),
2, 1, 1,
ARRAY[
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 1, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0, 0]
]::double precision[][]
) AS rast
)
SELECT title, geom AS geom
FROM foo
CROSS JOIN LATERAL (VALUES
('raster hull', ST_ConvexHull(rast)),
('all bands', ST_MinConvexHull(rast)),
('band 1', ST_MinConvexHull(rast, 1)),
('band 2', ST_MinConvexHull(rast, 2))
) AS variants(title, geom);title | geom -------------+--------------------------------------- raster hull | POLYGON((0 0,9 0,9 -9,0 -9,0 0)) all bands | POLYGON((0 -3,9 -3,9 -9,0 -9,0 -3)) band 1 | POLYGON((3 -3,9 -3,9 -6,3 -6,3 -3)) band 2 | POLYGON((0 -3,6 -3,6 -9,0 -9,0 -3))
ST_Polygon — Returnerar en multipolygongeometri som bildas av sammanslagningen av pixlar som har ett pixelvärde som inte är något datavärde. Om inget bandnummer anges är standardvärdet för bandnum 1.
geometry ST_Polygon(raster rast, integer band_num=1);
Ändrad 3.3.0, validering och fixering är inaktiverad för att förbättra prestanda. Kan resultera i ogiltiga geometrier.
Tillgänglighet: 0.1.6 Kräver GDAL 1.7 eller högre.
Förbättrad: 2.1.0 Förbättrad hastighet (helt C-baserad) och den returnerande multipolygonen är säkerställd att vara giltig.
Ändrad: 2.1.0 I tidigare versioner returnerades ibland en polygon, ändrat till att alltid returnera multipolygon.
Compare polygonization of every pixel with polygonization after zero is assigned as the NODATA value. The latter preserves the gap formed by zero-valued cells.
WITH source AS (
SELECT ST_SetValues(
ST_AddBand(
ST_MakeEmptyRaster(4, 4, 0, 4, 1, -1, 0, 0, 0),
1, '8BUI', 1, NULL
),
1, 1, 1,
ARRAY[
[1, 1, 1, 1],
[1, 0, 0, 1],
[1, 1, 0, 1],
[1, 1, 1, 1]
]::double precision[][]
) AS rast
), variants AS (
SELECT 'all pixels' AS title, ST_Polygon(rast) AS geom
FROM source
UNION ALL
SELECT
'zero excluded',
ST_Polygon(ST_SetBandNoDataValue(rast, 1, 0))
FROM source
)
SELECT title, geom AS geom
FROM variants
ORDER BY CASE title
WHEN 'all pixels' THEN 1
ELSE 2
END;title | geom ---------------+---------------------------------------------------------------------- all pixels | MULTIPOLYGON(((0 4,4 4,4 0,0 0,0 4))) zero excluded | MULTIPOLYGON(((0 4,0 0,4 0,4 4,0 4),(1 3,3 3,3 1,2 1,2 2,1 2,1 3))) (2 rows)
ST_IntersectionFractions — Beräknar den del av varje rastercell som täcks av en given geometri.
raster ST_IntersectionFractions(raster rast, geometry geom);
Beräknar den del av varje rastercell som täcks av en given geometri. Det första argumentet är en raster som definierar rutnätets geometri som ska användas för beräkningen. Omfattningen och cellstorleken läses från rasterparametern. Det andra argumentet är en geometri som läggs över rutnätet, och varje rutnät fylls i baserat på överlagringen av geometrin på rutnätet. För polygoner är det värde som returneras för varje cell andelen av dess area som täcks av geometrin. För linjesträngar är det värde som returneras för varje cell längden som ingår i cellen.
Tillgänglighet: 3.6.0 Kräver GEOS 3.14 eller högre.
This rotated square polygon covers half of each cell in the raster.
CREATE TABLE raster_proportions_rast (
name text,
rast raster
);
INSERT INTO raster_proportions_rast (name, rast) VALUES (
'2x2 raster covering 0,0 to 10,10',
ST_MakeEmptyRaster(2, 2, -- raster width/height in pixels
0, 10, -- upper-left corner x/y coordinates
5, -5, -- pixel width/height in ground units
0, 0, -- skew x/y
0 -- SRID
));
SELECT name, ST_DumpValues(
ST_IntersectionFractions(
rast,
'POLYGON((5 0,0 5,5 10,10 5,5 0))'::geometry),
1)
FROM raster_proportions_rast;2x2 raster covering 0,0 to 10,10
---------------------------------
{{0.5,0.5},{0.5,0.5}}TRUE om A:s avgränsande box skär B:s avgränsande box.TRUE om A:s avgränsande box är till vänster om B:s.TRUE om A:s avgränsande box ligger till höger om B:s.TRUE om A:s avgränsande box är densamma som B:s. Använder avgränsningsbox med dubbel precision.TRUE om A:s avgränsande box är innesluten i B:s. Använder avgränsande box med dubbel precision.TRUE om A:s avgränsande box är densamma som B:s.TRUE om A:s avgränsande box innehåller B:s. Använder avgränsande box med dubbel precision.&& — Returnerar TRUE om A:s avgränsande box skär B:s avgränsande box.
boolean &&( raster A , raster B );
boolean &&( raster A , geometry B );
boolean &&( geometry B , raster A );
Operatorn && returnerar TRUE om begränsningsrutan för raster/geometr A skär begränsningsrutan för raster/geometr B.
![]() | |
Detta operand kommer att använda alla index som kan finnas tillgängliga på rastren. |
Tillgänglighet: 2.0.0
SELECT A.rid As a_rid, B.rid As b_rid, A.rast && B.rast As intersect FROM dummy_rast AS A CROSS JOIN dummy_rast AS B LIMIT 3;
a_rid | b_rid | intersect
-------+-------+---------
2 | 2 | t
2 | 3 | f
2 | 1 | f&< — Returnerar TRUE om A:s avgränsande box är till vänster om B:s.
boolean &<( raster A , raster B );
Operatorn &< returnerar TRUE om begränsningsrutan för raster A överlappar eller ligger till vänster om begränsningsrutan för raster B, eller mer exakt, överlappar eller INTE ligger till höger om begränsningsrutan för raster B.
![]() | |
Detta operand kommer att använda alla index som kan finnas tillgängliga på rastren. |
SELECT A.rid As a_rid, B.rid As b_rid, A.rast &< B.rast As overleft FROM dummy_rast AS A CROSS JOIN dummy_rast AS B;
a_rid | b_rid | overleft
------+-------+----------
2 | 2 | t
2 | 3 | f
2 | 1 | f
3 | 2 | t
3 | 3 | t
3 | 1 | f
1 | 2 | t
1 | 3 | t
1 | 1 | t
&> — Returnerar TRUE om A:s avgränsande box ligger till höger om B:s.
boolean &>( raster A , raster B );
Operatorn &> returnerar TRUE om raster A:s avgränsande box överlappar eller ligger till höger om raster B:s avgränsande box, eller mer exakt, överlappar eller INTE ligger till vänster om raster B:s avgränsande box.
![]() | |
Detta operand kommer att använda alla index som kan finnas tillgängliga på geometrierna. |
SELECT A.rid As a_rid, B.rid As b_rid, A.rast & > B.rast As overright FROM dummy_rast AS A CROSS JOIN dummy_rast AS B;
a_rid | b_rid | overright
-------+-------+----------
2 | 2 | t
2 | 3 | t
2 | 1 | t
3 | 2 | f
3 | 3 | t
3 | 1 | f
1 | 2 | f
1 | 3 | t
1 | 1 | t
= — Returnerar TRUE om A:s avgränsande box är densamma som B:s. Använder avgränsningsbox med dubbel precision.
boolean =( raster A , raster B );
Operatorn = returnerar SANT om gränsboxen för raster A är densamma som gränsboxen för raster B. PostgreSQL använder operatorerna =, < och > som definieras för raster för att utföra interna ordningar och jämförelse av raster (dvs. i en GROUP BY- eller ORDER BY-klausul).
![]() | |
Denna operand kommer INTE att använda några index som kan finnas tillgängliga på rastren. Använd ~= istället. Den här operatorn finns främst för att man ska kunna gruppera efter rasterkolumnen. |
Tillgänglighet: 2.1.0
@ — Returnerar TRUE om A:s avgränsande box är innesluten i B:s. Använder avgränsande box med dubbel precision.
boolean @( raster A , raster B );
boolean @( geometry A , raster B );
boolean @( raster B , geometry A );
Operatorn @ returnerar TRUE om begränsningsrutan för raster/geometri A ingår i begränsningsrutan för raster/geometri B.
![]() | |
Detta operand kommer att använda spatiala index på rastrerna. |
Tillgänglighet: 2.0.0 raster @ raster, raster @ geometri infördes
Tillgänglighet: 2.0.5 geometry @ raster infördes
~= — Returnerar TRUE om A:s avgränsande box är densamma som B:s.
boolean ~=( raster A , raster B );
Operatorn ~= returnerar TRUE om begränsningsrutan för raster A är densamma som begränsningsrutan för raster B.
![]() | |
Detta operand kommer att använda alla index som kan finnas tillgängliga på rastren. |
Tillgänglighet: 2.0.0
Ett mycket användbart användarfall är att ta två uppsättningar av enkelbandsraster som är av samma stycke men representerar olika teman och skapa ett flerbandsraster
SELECT ST_AddBand(prec.rast, alt.rast) As new_rast
FROM prec INNER JOIN alt ON (prec.rast ~= alt.rast);
~ — Returnerar TRUE om A:s avgränsande box innehåller B:s. Använder avgränsande box med dubbel precision.
boolean ~( raster A , raster B );
boolean ~( geometry A , raster B );
boolean ~( raster B , geometry A );
Operatorn ~ returnerar TRUE om begränsningsrutan för raster/geometri A innehåller begränsningsrutan för raster/geometri B.
![]() | |
Detta operand kommer att använda spatiala index på rastrerna. |
Tillgänglighet: 2.0.0
ST_Contains — Returnerar true om inga punkter i raster rastB ligger i raster rastA:s exteriör och minst en punkt i rastB:s interiör ligger i rastA:s interiör.
boolean ST_Contains( raster rastA , integer nbandA , raster rastB , integer nbandB );
boolean ST_Contains( raster rastA , raster rastB );
Raster rastA innehåller rastB om och endast om inga punkter i rastB ligger i rastA:s utsida och minst en punkt i rastB:s insida ligger i rastA:s insida. Om bandnumret inte anges (eller sätts till NULL), beaktas endast rastrets konvexa skrov i testet. Om bandnumret anges är det endast de pixlar som har ett värde (inte NODATA) som beaktas i testet.
![]() | |
Denna funktion kommer att använda alla index som kan finnas tillgängliga på rastren. |
![]() | |
Om du vill testa det spatiala förhållandet mellan ett raster och en geometri använder du ST_Polygon på rastret, t.ex. ST_Contains(ST_Polygon(raster), geometry) eller ST_Contains(geometry, ST_Polygon(raster)). |
![]() | |
ST_Contains() är inversen av ST_Within(). Så ST_Contains(rastA, rastB) innebär ST_Within(rastB, rastA). |
Tillgänglighet: 2.1.0
Specified band numbers.
SELECT r1.rid, r2.rid, ST_Contains(r1.rast, 1, r2.rast, 1) FROM dummy_rast r1 CROSS JOIN dummy_rast r2 WHERE r1.rid = 1;
NOTICE: The first raster provided has no bands rid | rid | st_contains -----+-----+------------- 1 | 1 | 1 | 2 | f
No band numbers specified.
SELECT r1.rid, r2.rid, ST_Contains(r1.rast, r2.rast) FROM dummy_rast r1 CROSS JOIN dummy_rast r2 WHERE r1.rid = 1;
rid | rid | st_contains -----+-----+------------- 1 | 1 | t 1 | 2 | f
ST_ContainsProperly — Returnerar true om rastB skär rastA:s insida men inte rastA:s gräns eller utsida.
boolean ST_ContainsProperly( raster rastA , integer nbandA , raster rastB , integer nbandB );
boolean ST_ContainsProperly( raster rastA , raster rastB );
Raster rastA innehåller korrekt rastB om rastB skär rastA:s inre men inte rastA:s gräns eller yttre. Om bandnumret inte anges (eller sätts till NULL), beaktas endast rastrets konvexa skrov i testet. Om bandnumret anges är det endast de pixlar som har ett värde (inte NODATA) som beaktas i testet.
Raster rastA innehåller inte riktigt sig själv men innehåller sig själv.
![]() | |
Denna funktion kommer att använda alla index som kan finnas tillgängliga på rastren. |
![]() | |
Om du vill testa det spatiala förhållandet mellan ett raster och en geometri använder du ST_Polygon på rastret, t.ex. ST_ContainsProperly(ST_Polygon(raster), geometry) eller ST_ContainsProperly(geometry, ST_Polygon(raster)). |
Tillgänglighet: 2.1.0
SELECT r1.rid, r2.rid, ST_ContainsProperly(r1.rast, 1, r2.rast, 1) FROM dummy_rast r1 CROSS JOIN dummy_rast r2 WHERE r1.rid = 2;
rid | rid | st_containsproperly -----+-----+--------------------- 2 | 1 | f 2 | 2 | f
ST_Covers — Returnerar true om inga punkter i raster rastB ligger utanför raster rastA.
boolean ST_Covers( raster rastA , integer nbandA , raster rastB , integer nbandB );
boolean ST_Covers( raster rastA , raster rastB );
Raster rastA täcker rastB om och endast om inga punkter i rastB ligger i rastA:s utsida. Om bandnumret inte anges (eller sätts till NULL), beaktas endast rastrets konvexa skrov i testet. Om bandnumret anges är det endast de pixlar som har ett värde (inte NODATA) som beaktas i testet.
![]() | |
Denna funktion kommer att använda alla index som kan finnas tillgängliga på rastren. |
![]() | |
Om du vill testa det spatiala förhållandet mellan ett raster och en geometri använder du ST_Polygon på rastret, t.ex. ST_Covers(ST_Polygon(raster), geometry) eller ST_Covers(geometry, ST_Polygon(raster)). |
Tillgänglighet: 2.1.0
SELECT r1.rid, r2.rid, ST_Covers(r1.rast, 1, r2.rast, 1) FROM dummy_rast r1 CROSS JOIN dummy_rast r2 WHERE r1.rid = 2;
rid | rid | st_covers -----+-----+----------- 2 | 1 | f 2 | 2 | t
ST_CoveredBy — Returnerar true om inga punkter i raster rastA ligger utanför raster rastB.
boolean ST_CoveredBy( raster rastA , integer nbandA , raster rastB , integer nbandB );
boolean ST_CoveredBy( raster rastA , raster rastB );
Raster rastA täcks av rastB om och endast om inga punkter i rastA ligger i rastB:s utsida. Om bandnumret inte anges (eller sätts till NULL), beaktas endast rastrets konvexa skrov i testet. Om bandnumret anges är det endast de pixlar som har ett värde (inte NODATA) som beaktas i testet.
![]() | |
Denna funktion kommer att använda alla index som kan finnas tillgängliga på rastren. |
![]() | |
För att testa det spatiala förhållandet mellan ett raster och en geometri använder du ST_Polygon på rastret, t.ex. ST_CoveredBy(ST_Polygon(raster), geometry) eller ST_CoveredBy(geometry, ST_Polygon(raster)). |
Tillgänglighet: 2.1.0
SELECT r1.rid, r2.rid, ST_CoveredBy(r1.rast, 1, r2.rast, 1) FROM dummy_rast r1 CROSS JOIN dummy_rast r2 WHERE r1.rid = 2;
rid | rid | st_coveredby -----+-----+-------------- 2 | 1 | f 2 | 2 | t
ST_Disjoint — Returnerar true om raster rastA inte spatialt korsar rastB.
boolean ST_Disjoint( raster rastA , integer nbandA , raster rastB , integer nbandB );
boolean ST_Disjoint( raster rastA , raster rastB );
Raster rastA och rastB är disjointed om de inte delar något utrymme tillsammans. Om bandnumret inte anges (eller sätts till NULL), beaktas endast rastrets konvexa skrov i testet. Om bandnumret anges är det endast de pixlar som har ett värde (inte NODATA) som beaktas i testet.
![]() | |
Denna funktion använder INTE några index. |
![]() | |
Om du vill testa det spatiala förhållandet mellan ett raster och en geometri använder du ST_Polygon på rastret, t.ex. ST_Disjoint(ST_Polygon(raster), geometry). |
Tillgänglighet: 2.1.0
Rid = 1 has no bands, hence the NOTICE and the NULL value for st_disjoint.
SELECT r1.rid, r2.rid, ST_Disjoint(r1.rast, 1, r2.rast, 1) FROM dummy_rast r1 CROSS JOIN dummy_rast r2 WHERE r1.rid = 2;
NOTICE: The second raster provided has no bands rid | rid | st_disjoint -----+-----+------------- 2 | 1 | 2 | 2 | f
This time, without specifying band numbers.
SELECT r1.rid, r2.rid, ST_Disjoint(r1.rast, r2.rast) FROM dummy_rast r1 CROSS JOIN dummy_rast r2 WHERE r1.rid = 2;
rid | rid | st_disjoint -----+-----+------------- 2 | 1 | t 2 | 2 | f
ST_Intersects — Returnerar true om raster rastA spatialt korsar raster rastB.
boolean ST_Intersects( raster rastA , integer nbandA , raster rastB , integer nbandB );
boolean ST_Intersects( raster rastA , raster rastB );
boolean ST_Intersects( raster rast , integer nband , geometry geommin );
boolean ST_Intersects( raster rast , geometry geommin , integer nband=NULL );
boolean ST_Intersects( geometry geommin , raster rast , integer nband=NULL );
Returnerar true om raster rastA spatialt korsar raster rastB. Om bandnumret inte anges (eller sätts till NULL), beaktas endast rastrets konvexa skrov i testet. Om bandnumret anges, beaktas endast de pixlar som har ett värde (inte NODATA) i testet.
![]() | |
Denna funktion kommer att använda alla index som kan finnas tillgängliga på rastren. |
Förbättrad: 2.0.0 stöd för raster/raster intersects introducerades.
![]() | |
Ändrad: 2.1.0 Beteendet för ST_Intersects(raster, geometri)-varianterna ändrades så att det överensstämmer med beteendet för ST_Intersects(geometri, raster). |
Different bands of same raster.
SELECT ST_Intersects(rast, 2, rast, 3) FROM dummy_rast WHERE rid = 2;
t
ST_Overlaps — Returnerar true om raster rastA och rastB korsar varandra men det ena inte helt innehåller det andra.
boolean ST_Overlaps( raster rastA , integer nbandA , raster rastB , integer nbandB );
boolean ST_Overlaps( raster rastA , raster rastB );
Returnerar true om raster rastA spatialt överlappar raster rastB. Detta innebär att rastA och rastB korsar varandra men att den ena inte helt innehåller den andra. Om bandnumret inte anges (eller om det sätts till NULL), beaktas endast rastrets konvexa skrov i testet. Om bandnumret anges är det endast de pixlar som har ett värde (inte NODATA) som beaktas i testet.
![]() | |
Denna funktion kommer att använda alla index som kan finnas tillgängliga på rastren. |
![]() | |
Om du vill testa det spatiala förhållandet mellan ett raster och en geometri använder du ST_Polygon på rastret, t.ex. ST_Overlaps(ST_Polygon(raster), geometry). |
Tillgänglighet: 2.1.0
Comparing different bands of same raster.
SELECT ST_Overlaps(rast, 1, rast, 2) FROM dummy_rast WHERE rid = 2;
f
ST_Touches — Returnerar true om raster rastA och rastB har minst en gemensam punkt men deras inre delar inte skär varandra.
boolean ST_Touches( raster rastA , integer nbandA , raster rastB , integer nbandB );
boolean ST_Touches( raster rastA , raster rastB );
Returnerar true om raster rastA spatialt berör raster rastB. Detta innebär att rastA och rastB har minst en gemensam punkt men att deras inre delar inte skär varandra. Om bandnumret inte anges (eller sätts till NULL), beaktas endast rastrets konvexa skrov i testet. Om bandnumret anges är det endast de pixlar som har ett värde (inte NODATA) som beaktas i testet.
![]() | |
Denna funktion kommer att använda alla index som kan finnas tillgängliga på rastren. |
![]() | |
För att testa det spatiala förhållandet mellan ett raster och en geometri, använd ST_Polygon på rastret, t.ex. ST_Touches(ST_Polygon(raster), geometry). |
Tillgänglighet: 2.1.0
SELECT r1.rid, r2.rid, ST_Touches(r1.rast, 1, r2.rast, 1) FROM dummy_rast r1 CROSS JOIN dummy_rast r2 WHERE r1.rid = 2;
rid | rid | st_touches -----+-----+------------ 2 | 1 | f 2 | 2 | f
ST_SameAlignment — Returnerar true om raster har samma skevhet, skala, spatiala ref och offset (pixlar kan placeras i samma rutnät utan att skära i pixlar) och false om de inte har det med ett meddelande om detaljproblem.
boolean ST_SameAlignment( raster rastA , raster rastB );
boolean ST_SameAlignment( double precision ulx1 , double precision uly1 , double precision scalex1 , double precision scaley1 , double precision skewx1 , double precision skewy1 , double precision ulx2 , double precision uly2 , double precision scalex2 , double precision scaley2 , double precision skewx2 , double precision skewy2 );
boolean ST_SameAlignment( raster set rastfield );
Icke-aggregerad version (variant 1 och 2): Returnerar true om de två rastren (antingen tillhandahållna direkt eller skapade med hjälp av värdena för upperleft, scale, skew och srid) har samma scale, skew, srid och om minst ett av de fyra hörnen av en pixel i ett raster faller på ett hörn av rutnätet i det andra rastret. Returnerar false om så inte är fallet och ett NOTICE som beskriver justeringsproblemet.
Aggregerad version (Variant 3): Från en uppsättning raster returneras sant om alla raster i uppsättningen är inriktade. ST_SameAlignment () -funktionen är en "aggregerad" funktion i terminologin för PostgreSQL. Det betyder att den fungerar på rader med data, på samma sätt som SUM () och AVG () -funktionerna gör.
Tillgänglighet: 2.0.0
Förbättrad: 2.1.0 tillägg av Aggregate-variant
SELECT ST_SameAlignment(ST_MakeEmptyRaster(1, 1, 0, 0, 1, 1, 0, 0),
ST_MakeEmptyRaster(1, 1, 0, 0, 1, 1, 0, 0)
) as sm;t
SELECT ST_SameAlignment(A.rast, b.rast) FROM dummy_rast AS A CROSS JOIN dummy_rast AS B;
NOTICE: The two rasters provided have different SRIDs NOTICE: The two rasters provided have different SRIDs t f f f
ST_NotSameAlignmentReason — Returnerar text som anger om rastrerna är inriktade och om de inte är inriktade, en anledning till varför.
text ST_NotSameAlignmentReason(raster rastA, raster rastB);
Returnerar text som anger om rastrerna är inriktade och om de inte är inriktade, en anledning till varför.
![]() | |
Om det finns flera anledningar till att rastrerna inte är i linje kommer endast en anledning (det första testet som misslyckas) att returneras. |
Tillgänglighet: 2.1.0
SELECT
ST_SameAlignment(ST_MakeEmptyRaster(1, 1, 0, 0, 1, 1, 0, 0),
ST_MakeEmptyRaster(1, 1, 0, 0, 1.1, 1.1, 0, 0)
),
ST_NotSameAlignmentReason(ST_MakeEmptyRaster(1, 1, 0, 0, 1, 1, 0, 0),
ST_MakeEmptyRaster(1, 1, 0, 0, 1.1, 1.1, 0, 0)
)
;st_samealignment | st_notsamealignmentreason ------------------+------------------------------------------------- f | The rasters have different scales on the X axis (1 row)
ST_Within — Returnerar true om inga punkter i raster rastA ligger i raster rastB:s exteriör och minst en punkt i rastA:s interiör ligger i rastB:s interiör.
boolean ST_Within( raster rastA , integer nbandA , raster rastB , integer nbandB );
boolean ST_Within( raster rastA , raster rastB );
Raster rastA ligger inom rastB om och endast om inga punkter i rastA ligger i rastB:s utsida och minst en punkt i rastA:s insida ligger i rastB:s insida. Om bandnumret inte anges (eller sätts till NULL), beaktas endast rastrets konvexa skrov i testet. Om bandnumret anges är det endast de pixlar som har ett värde (inte NODATA) som beaktas i testet.
![]() | |
Detta operand kommer att använda alla index som kan finnas tillgängliga på rastren. |
![]() | |
Om du vill testa det spatiala förhållandet mellan ett raster och en geometri använder du ST_Polygon på rastret, t.ex. ST_Within(ST_Polygon(raster), geometry) eller ST_Within(geometry, ST_Polygon(raster)). |
![]() | |
ST_Within() är inversen av ST_Contains(). Så ST_Within(rastA, rastB) innebär ST_Contains(rastB, rastA). |
Tillgänglighet: 2.1.0
SELECT r1.rid, r2.rid, ST_Within(r1.rast, 1, r2.rast, 1) FROM dummy_rast r1 CROSS JOIN dummy_rast r2 WHERE r1.rid = 2;
rid | rid | st_within -----+-----+----------- 2 | 1 | f 2 | 2 | t
ST_DWithin — Returnerar true om rasterna rastA och rastB ligger inom det angivna avståndet från varandra.
boolean ST_DWithin( raster rastA , integer nbandA , raster rastB , integer nbandB , double precision distance_of_srid );
boolean ST_DWithin( raster rastA , raster rastB , double precision distance_of_srid );
Returnerar true om rastren rastA och rastB ligger inom det angivna avståndet från varandra. Om bandnumret inte anges (eller sätts till NULL), beaktas endast rastrets konvexa skrov i testet. Om bandnumret anges är det endast de pixlar som har ett värde (inte NODATA) som beaktas i testet.
Avståndet anges i enheter som definieras av rastrernas spatiala referenssystem. För att denna funktion ska vara meningsfull måste källrastren ha samma koordinatprojektion och samma SRID.
![]() | |
Detta operand kommer att använda alla index som kan finnas tillgängliga på rastren. |
![]() | |
Om du vill testa det spatiala förhållandet mellan ett raster och en geometri använder du ST_Polygon på rastret, t.ex. ST_DWithin(ST_Polygon(raster), geometry). |
Tillgänglighet: 2.1.0
SELECT r1.rid, r2.rid, ST_DWithin(r1.rast, 1, r2.rast, 1, 3.14) FROM dummy_rast r1 CROSS JOIN dummy_rast r2 WHERE r1.rid = 2;
rid | rid | st_dwithin -----+-----+------------ 2 | 1 | f 2 | 2 | t
ST_DFullyWithin — Returnerar true om rasterna rastA och rastB är helt inom det angivna avståndet från varandra.
boolean ST_DFullyWithin( raster rastA , integer nbandA , raster rastB , integer nbandB , double precision distance_of_srid );
boolean ST_DFullyWithin( raster rastA , raster rastB , double precision distance_of_srid );
Returnerar true om rastren rastA och rastB är helt inom det angivna avståndet från varandra. Om bandnumret inte anges (eller sätts till NULL), beaktas endast rastrets konvexa skrov i testet. Om bandnumret anges är det endast de pixlar som har ett värde (inte NODATA) som beaktas i testet.
Avståndet anges i enheter som definieras av rastrernas spatiala referenssystem. För att denna funktion ska vara meningsfull måste källrastren ha samma koordinatprojektion och samma SRID.
![]() | |
Detta operand kommer att använda alla index som kan finnas tillgängliga på rastren. |
![]() | |
Om du vill testa det spatiala förhållandet mellan ett raster och en geometri använder du ST_Polygon på rastret, t.ex. ST_DFullyWithin(ST_Polygon(raster), geometry). |
Tillgänglighet: 2.1.0
SELECT r1.rid, r2.rid, ST_DFullyWithin(r1.rast, 1, r2.rast, 1, 3.14) FROM dummy_rast r1 CROSS JOIN dummy_rast r2 WHERE r1.rid = 2;
rid | rid | st_dfullywithin -----+-----+----------------- 2 | 1 | f 2 | 2 | t
Detta avsnitt dokumenterar olika problem och tips relaterade till PostGIS Raster.
När GDAL öppnar en fil söker GDAL ivrigt igenom filens katalog för att bygga upp en katalog över andra filer. Om den här katalogen innehåller många filer (t.ex. tusentals, miljontals) blir det extremt långsamt att öppna filen (särskilt om filen råkar finnas på en nätverksenhet som t.ex. NFS).
För att kontrollera detta beteende tillhandahåller GDAL följande miljövariabel: GDAL_DISABLE_READDIR_ON_OPEN. Ställ in GDAL_DISABLE_READDIR_ON_OPEN till TRUE för att inaktivera katalogsökning.
I Ubuntu (och förutsatt att du använder PostgreSQL: s paket för Ubuntu) kan GDAL_DISABLE_READDIR_ON_OPEN ställas in i /etc/postgresql/POSTGRESQL_VERSION/CLUSTER_NAME/environment (där POSTGRESQL_VERSION är versionen av PostgreSQL, t.ex. 9.6 och CLUSTER_NAME är namnet på klustret, t.ex. maindb). Du kan också ställa in PostGIS-miljövariabler här också.
# environment variables for postmaster process
# This file has the same syntax as postgresql.conf:
# VARIABLE = simple_value
# VARIABLE2 = 'any value!'
# I. e. you need to enclose any value which does not only consist of letters,
# numbers, and '-', '_', '.' in single quotes. Shell commands are not
# evaluated.
POSTGIS_GDAL_ENABLED_DRIVERS = 'ENABLE_ALL'
POSTGIS_ENABLE_OUTDB_RASTERS = 1
GDAL_DISABLE_READDIR_ON_OPEN = 'TRUE'
Det maximala antalet öppna filer som tillåts av Linux och PostgreSQL är vanligtvis konservativa (vanligtvis 1024 öppna filer per process) med tanke på antagandet att systemet konsumeras av mänskliga användare. För Out-DB Rasters kan en enda giltig fråga lätt överskrida denna gräns (t.ex. en dataset med 10 års värde av raster med en raster för varje dag som innehåller minimi- och maximitemperaturer och vi vill veta det absoluta min- och maxvärdet för en pixel i den datasetet).
Den enklaste ändringen att göra är följande PostgreSQL-inställning: max_files_per_process. Standardvärdet är inställt på 1000, vilket är alldeles för lågt för Out-DB Rasters. Ett säkert startvärde kan vara 65536 men detta beror verkligen på dina datamängder och de frågor som körs mot dessa datamängder. Denna inställning kan endast göras vid serverstart och förmodligen endast i PostgreSQL-konfigurationsfilen (t.ex. /etc/postgresql/POSTGRESQL_VERSION/CLUSTER_NAME/postgresql.conf i Ubuntu-miljöer).
...
# - Kernel Resource Usage -
max_files_per_process = 65536 # min 25
# (change requires restart)
...
Den största förändringen som måste göras är Linux-kärnans gränser för öppna filer. Det finns två delar i detta:
Maximalt antal öppna filer för hela systemet
Maximalt antal öppna filer per process
Du kan kontrollera det aktuella maximala antalet öppna filer för hela systemet med hjälp av följande exempel:
$ sysctl -a | grep fs.file-max
fs.file-max = 131072
Om det värde som returneras inte är tillräckligt stort lägger du till en fil i /etc/sysctl.d / enligt följande exempel:
$ echo "fs.file-max = 6145324" >> /etc/sysctl.d/fs.conf
$ cat /etc/sysctl.d/fs.conf
fs.file-max = 6145324
$ sysctl -p --system
* Applying /etc/sysctl.d/fs.conf ...
fs.file-max = 2097152
* Applying /etc/sysctl.conf ...
$ sysctl -a | grep fs.file-max
fs.file-max = 6145324
Vi måste öka det maximala antalet öppna filer per process för PostgreSQL-serverprocesserna.
För att se vad de aktuella PostgreSQL-serviceprocesserna använder för maximalt antal öppna filer, gör enligt följande exempel (se till att PostgreSQL körs):
$ ps aux | grep postgres
postgres 31713 0.0 0.4 179012 17564 pts/0 S Dec26 0:03 /home/dustymugs/devel/postgresql/sandbox/10/usr/local/bin/postgres -D /home/dustymugs/devel/postgresql/sandbox/10/pgdata postgres 31716 0.0 0.8 179776 33632 ? Ss Dec26 0:01 postgres: checkpointer process postgres 31717 0.0 0.2 179144 9416 ? Ss Dec26 0:05 postgres: writer process postgres 31718 0.0 0.2 179012 8708 ? Ss Dec26 0:06 postgres: wal writer process postgres 31719 0.0 0.1 179568 7252 ? Ss Dec26 0:03 postgres: autovacuum launcher process postgres 31720 0.0 0.1 34228 4124 ? Ss Dec26 0:09 postgres: stats collector process postgres 31721 0.0 0.1 179308 6052 ? Ss Dec26 0:00 postgres: bgworker: logical replication launcher
$ cat /proc/31718/limits
Limit Soft Limit Hard Limit Units
Max cpu time unlimited unlimited seconds
Max file size unlimited unlimited bytes
Max data size unlimited unlimited bytes
Max stack size 8388608 unlimited bytes
Max core file size 0 unlimited bytes
Max resident set unlimited unlimited bytes
Max processes 15738 15738 processes
Max open files 1024 4096 files
Max locked memory 65536 65536 bytes
Max address space unlimited unlimited bytes
Max file locks unlimited unlimited locks
Max pending signals 15738 15738 signals
Max msgqueue size 819200 819200 bytes
Max nice priority 0 0
Max realtime priority 0 0
Max realtime timeout unlimited unlimited us
I exemplet ovan inspekterade vi gränsen för öppna filer för process 31718. Det spelar ingen roll vilken PostgreSQL-process, någon av dem kommer att göra. Svaret vi är intresserade av är Max öppna filer.
Vi vill öka Soft Limit och Hard Limit för Max öppna filer för att vara större än det värde vi angav för PostgreSQL-inställningen max_files_per_process. I vårt exempel ställer vi in max_files_per_process till 65536.
I Ubuntu (och förutsatt att du använder PostgreSQL: s paket för Ubuntu) är det enklaste sättet att ändra Soft Limit och Hard Limit att redigera /etc/init.d/postgresql (SysV) eller /lib/systemd/system/postgresql * .service (systemd).
Låt oss först ta itu med SysV Ubuntu-fallet där vi lägger till ulimit -H -n 262144 och ulimit -n 131072 i /etc/init.d/postgresql.
...
case "$1" in
start|stop|restart|reload)
if [ "$1" = "start" ]; then
create_socket_directory
fi
if [ -z "`pg_lsclusters -h`" ]; then
log_warning_msg 'No PostgreSQL clusters exist; see "man pg_createcluster"'
exit 0
fi
ulimit -H -n 262144
ulimit -n 131072
for v in $versions; do
$1 $v || EXIT=$?
done
exit ${EXIT:-0}
;;
status)
...
Nu ska vi ta itu med systemd Ubuntu-fallet. Vi kommer att lägga till LimitNOFILE=131072 i varje /lib/systemd/system/postgresql*.service-fil i avsnittet [Service].
...
[Service]
LimitNOFILE=131072
...
[Install]
WantedBy=multi-user.target
...
När du har gjort de nödvändiga ändringarna i systemd ska du se till att ladda om daemon
systemctl daemon-reload
Detta kapitel dokumenterar funktioner som finns i mappen extras i PostGIS-källans tarballs och källförvar. Dessa är inte alltid paketerade med PostGIS binära utgåvor, men är vanligtvis PL/pgSQL-baserade eller standardskalskript som kan köras som de är.
Funktionerna nedan är spatiala aggregatfunktioner som används på samma sätt som SQL-aggregatfunktioner som summa och genomsnitt.
Funktionerna nedan är spatiala fönsterfunktioner som används på samma sätt som SQL-fönsterfunktioner som row_number(), lead() och lag(). De måste följas av en OVER() -klausul.
De funktioner som anges nedan är PostGIS-funktioner som överensstämmer med SQL/MM 3-standarden
De funktioner och operatorer som anges nedan är PostGIS-funktioner/operatorer som tar som indata eller returnerar som utdata ett geografiskt datatypobjekt.
![]() | |
Funktioner med ett (T) är inte inbyggda geodetiska funktioner och använder ett ST_Transform-anrop till och från geometri för att utföra operationen. Därför kanske de inte beter sig som förväntat när de går över datalinjer, poler och för stora geometrier eller geometripar som täcker mer än en UTM-zon. Grundtransform - (föredrar UTM, Lambert Azimuthal (North/South), och faller tillbaka på Mercator i värsta fall) |
Nedanstående funktioner och operatorer är PostGIS funktioner/operatorer som tar som indata eller returnerar som utdata ett raster datatypobjekt. Listade i alfabetisk ordning.
Funktionerna som anges nedan är PostGIS-funktioner som tar som indata eller returnerar som utdata en uppsättning eller ett enda geometry_dump eller geomval datatypobjekt.
De funktioner som anges nedan är PostGIS-funktioner som tar som indata eller returnerar som utdata box*-familjen av PostGIS spatiala typer. Box-familjen av typer består av box2d och box3d
De funktioner som anges nedan är PostGIS-funktioner som inte kastar bort Z-index.
Funktionerna nedan är PostGIS-funktioner som kan använda CIRCULARSTRING, CURVEPOLYGON och andra krökta geometrityper
Funktionerna nedan är PostGIS-funktioner som kan använda geometrierna POLYHEDRALSURFACE, POLYHEDRALSURFACEM
Nedan finns en alfabetisk lista över spatiala specifika funktioner i PostGIS och de spatiala typer de arbetar med eller OGC/SQL-överensstämmelse som de försöker följa.
betyder att funktionen fungerar med typen eller subtypen i original.
betyder att det fungerar men med en transform cast inbyggd med cast till geometri, transformera till en "bästa srid" spatial ref och sedan casta tillbaka. Resultaten kanske inte blir som förväntat för stora områden eller områden vid poler och kan ackumulera flyttalsskräp.
betyder att funktionen fungerar med typen på grund av en auto-cast till en annan, t.ex. till box3d, snarare än direkt typstöd.
betyder att funktionen endast är tillgänglig om PostGIS har kompilerats med SFCGAL-stöd.
De funktioner som anges nedan är PostGIS-funktioner som har lagts till eller förbättrats.
Funktioner som är nya i PostGIS 3.7
Funktioner förbättrade i PostGIS 3.7
Funktioner ändrade i PostGIS 3.7
De funktioner som anges nedan är PostGIS-funktioner som har lagts till eller förbättrats.
Funktioner som är nya i PostGIS 3.6
Funktioner förbättrade i PostGIS 3.6
Funktioner ändrade i PostGIS 3.6
De funktioner som anges nedan är PostGIS-funktioner som har lagts till eller förbättrats.
Funktioner som är nya i PostGIS 3.5
Funktioner förbättrade i PostGIS 3.5
Funktioner ändrade i PostGIS 3.5
De funktioner som anges nedan är PostGIS-funktioner som har lagts till eller förbättrats.
Funktioner som är nya i PostGIS 3.4
Funktioner förbättrade i PostGIS 3.4
Funktioner ändrade i PostGIS 3.4
De funktioner som anges nedan är PostGIS-funktioner som har lagts till eller förbättrats.
Funktioner som är nya i PostGIS 3.3
Funktioner förbättrade i PostGIS 3.3
Funktioner ändrade i PostGIS 3.3
De funktioner som anges nedan är PostGIS-funktioner som har lagts till eller förbättrats.
Funktioner som är nya i PostGIS 3.2
Funktioner förbättrade i PostGIS 3.2
Funktioner ändrade i PostGIS 3.2
De funktioner som anges nedan är PostGIS-funktioner som har lagts till eller förbättrats.
Funktioner som är nya i PostGIS 3.1
Funktioner förbättrade i PostGIS 3.1
Funktioner ändrade i PostGIS 3.1
De funktioner som anges nedan är PostGIS-funktioner som har lagts till eller förbättrats.
Funktioner som är nya i PostGIS 3.0
Funktioner förbättrade i PostGIS 3.0
Funktioner ändrade i PostGIS 3.0
De funktioner som anges nedan är PostGIS-funktioner som har lagts till eller förbättrats.
Funktioner som är nya i PostGIS 2.5
Funktioner förbättrade i PostGIS 2.5
Funktioner ändrade i PostGIS 2.5
De funktioner som anges nedan är PostGIS-funktioner som har lagts till eller förbättrats.
Funktioner som är nya i PostGIS 2.4
Funktioner förbättrade i PostGIS 2.4
Funktioner ändrade i PostGIS 2.4
De funktioner som anges nedan är PostGIS-funktioner som har lagts till eller förbättrats.
Funktioner som är nya i PostGIS 2.3
Funktioner förbättrade i PostGIS 2.3
Funktioner ändrade i PostGIS 2.3
De funktioner som anges nedan är PostGIS-funktioner som har lagts till eller förbättrats.
Funktioner som är nya i PostGIS 2.2
Funktioner förbättrade i PostGIS 2.2
Funktioner ändrade i PostGIS 2.2
De funktioner som anges nedan är PostGIS-funktioner som har lagts till eller förbättrats.
Funktioner som är nya i PostGIS 2.1
Funktioner förbättrade i PostGIS 2.1
Funktioner ändrade i PostGIS 2.1
De funktioner som anges nedan är PostGIS-funktioner som har lagts till eller förbättrats.
Funktioner som är nya i PostGIS 2.0
Funktioner förbättrade i PostGIS 2.0
Funktioner ändrade i PostGIS 2.0
De funktioner som anges nedan är PostGIS-funktioner som har lagts till eller förbättrats.
Funktioner som är nya i PostGIS 1.5
De funktioner som anges nedan är PostGIS-funktioner som har lagts till eller förbättrats.
Funktioner som är nya i PostGIS 1.4
De funktioner som anges nedan är PostGIS-funktioner som har lagts till eller förbättrats.
Funktioner som är nya i PostGIS 1.3
Att rapportera buggar på ett effektivt sätt är ett grundläggande sätt att hjälpa PostGIS-utvecklingen. Den mest effektiva buggrapporten är den som gör det möjligt för PostGIS-utvecklare att reproducera den, så den skulle helst innehålla ett skript som utlöser den och all information om miljön där den upptäcktes. Tillräckligt bra information kan extraheras genom att köra SELECT postgis_full_version() [för PostGIS] och SELECT version() [för postgresql].
Om du inte använder den senaste versionen är det värt att ta en titt på versionens changelog först för att ta reda på om din bugg redan har åtgärdats.
Genom att använda PostGIS buggspårare säkerställer du att dina rapporter inte kasseras och håller dig informerad om hanteringsprocessen. Innan du rapporterar en ny bugg, kontrollera i databasen om den är känd och om den är det, lägg till eventuell ny information du har om den.
Du kanske vill läsa Simon Tathams artikel om hur du rapporterar buggar på ett effektivt sätt innan du skickar in en ny rapport.
Dokumentationen ska på ett korrekt sätt återspegla programvarans funktioner och beteende. Om den inte gör det kan det bero på en programvarufel eller på att dokumentationen är felaktig eller bristfällig.
Dokumentationsproblem kan också rapporteras till PostGIS bug tracker.
Om din revidering är trivial kan du bara beskriva den i ett nytt buggtrackerärende och ange dess plats i dokumentationen.
Om dina ändringar är mer omfattande är en patch definitivt att föredra. Detta är en process i fyra steg på Unix (förutsatt att du redan har git installerat):
Before editing or building the manual, read the repository's documentation development guide. It covers the executable example, generated figure, validation, HTML, and PDF workflows used by the manual.
Klona PostGIS git-repository. På Unix, skriv:
git clone https://git.osgeo.org/gitea/postgis/postgis.git
Detta kommer att lagras i katalogen postgis
Gör dina ändringar i dokumentationen med din favorittextredigerare. På Unix skriver du (till exempel):
vim doc/postgis.xml
Observera att dokumentationen är skriven i DocBook XML snarare än HTML, så om du inte är bekant med det, följ exemplet i resten av dokumentationen.
Skapa en patch-fil som innehåller skillnaderna från huvudkopian av dokumentationen. På Unix skriver du:
git diff doc/postgis.xml > doc.patch
Bifoga korrigeringen till ett nytt problem i buggtracker.
PostGIS is built and sustained by a worldwide community. This chapter records the people, organizations, funders, and upstream projects that have contributed code, documentation, infrastructure, testing, support, and funding.
The PostGIS Project Steering Committee (PSC) coordinates the general direction, release cycles, documentation, and outreach efforts for the PostGIS project. In addition the PSC provides general user support, accepts and approves patches from the general PostGIS community and votes on miscellaneous issues involving PostGIS such as developer commit access, new PSC members or significant API changes.
CI and website maintenance, Windows production and experimental builds, documentation, alignment of PostGIS with PostgreSQL releases, X3D support, management functions.
Index improvements, bug fixing and geometry/geography function improvements, SFCGAL, raster, GitHub curation, and ci maintenance.
Co-founder of PostGIS project. General bug fixing, geography support, geography and geometry index support (2D, 3D, nD index and anything spatial index), underlying geometry internal structures, GEOS functionality integration and alignment with GEOS releases, alignment of PostGIS with PostgreSQL releases, loader/dumper, and Shapefile GUI loader.
Bug fixes and maintenance, ci maintenance, git mirror management, management functions, integration of new GEOS functionality and alignment with GEOS releases, topology support, and raster framework and low level API functions.
Distance function enhancements (including 3D distance and relationship functions) and additions, Tiny WKB (TWKB) output format and general user support
SFCGAL enhancements and maintenance and ci support
Geometry clustering function additions, other geometry algorithm enhancements, GEOS enhancements and general user support
GEOS enhancements and documentation
MapBox Vector Tile, GeoBuf, and Flatgeobuf functions. Gitea testing and GitLab experimentation.
Geometry Processing, PostgreSQL gist, general bug fixing
Bug fixes, maintenance, stability, and performance
Prior PSC Member, MVT support, Bug fixing, Performance and stability improvements, GitHub curation, alignment of PostGIS with PostgreSQL releases
Prior PSC Member. Raster development, integration with GDAL, raster loader, user support, general bug fixing, testing on various OS (Slackware, Mac, Windows, and more)
Prior PSC Member. Coordinated bug fixing and maintenance effort, spatial index selectivity and binding, loader/dumper, and Shapefile GUI Loader, integration of new and new function enhancements.
Raster development, GDAL driver support, loader
(Emeritus) Input/output XML (KML,GML)/GeoJSON functions, 3D support and bug fixes.
Prior PSC Member. General development, site and buildbot maintenance, OSGeo incubation management
CMake support for PostGIS, built original raster loader in python and low level raster API functions
Prior PSC Member. Documentation and documentation support tools, buildbot maintenance, advanced user support on PostGIS newsgroup, and PostGIS maintenance function enhancements.
The original developer/Co-founder of PostGIS. Dave wrote the server side objects, index bindings, and many of the server side analytical functions.
Original development of the Shapefile loader/dumper.
Ongoing maintenance and development of core functions. Enhanced curve support. Shapefile GUI loader.
Architect of PostGIS raster implementation. Raster overall architecture, prototyping, programming support
Raster development (mostly map algebra analytic functions)
| @amwps290 (GitHub user) | Fabrice Fontaine | Markus Wanner |
| @kannes (GitHub user: Hannes) | Florentin Drogeanu | Matt Amos |
| @sunhm89 (GitHub user) | Florian Weimer | Matt Bretl |
| @wewindy (GitHub user: Chen) | François Bonzon | Matthias Bay |
| Adrien Berchet | Frank Warmerdam | Maxim Kochetkov |
| Alex Bodnaru | George Silva | Maxime Guillaud |
| Alex Mayrhofer | Gerald Fenoy | Maxime van Noppen |
| Andrea Peri | Gino Lucrezi | Maxime Schoemans |
| Andreas Forø Tollefsen | Giovanni Zezza | Megan Ma |
| Andreas Neumann | Grant Hutchins | Michael Fuhr |
| Andreas Schild | Greg Troxel | Michal Páleník |
| Andrew Gierth | Guillaume Lelarge | Mike Toews |
| Andrew Harvey | Giuseppe Broccolo | Mitchell Henke |
| Anne Ghisla | Han Wang | Nathan Wagner |
| Antoine Bajolet | Hannes Janetzek | Nathaniel Clay |
| Ariel Mashraki | Hans Lemuet | Nicolas Roelandt |
| Arno Renevier | Haribabu Kommi | Nikita Shulga |
| Arthur Bazin | Harrissou Sant-anna | Nikolai Berkoff |
| Arthur Lesuisse | Havard Tveite | Norman Barker |
| Artur Zakirov | IIDA Tetsushi | Norman Vine |
| Ayo Adesugba | Ingvild Nystuen | Patricia Tozer |
| Barbara Phillipot | Jackie Leng | Paul Norman |
| Baris Ergun | James Addison | Paulo Cesar Coronado |
| Bas Couwenberg | James Marca | Pavel Seleznev |
| Ben Jubb | Jan Katins | Pawel Ostrowski |
| Benjamin Morel | Jan Tojnar | Peter Nguyen |
| Bernd Reiß | Jason Smith | Pierre Cardinal |
| Bernhard Reiter | Jean Felder | Rafal Magda |
| Bill Mill | Jeff Adams | Ralph Mason |
| Björn Esser | Jelte Fennema | Rémi Cura |
| Brian Hamlin | Jim Jones | Richard Greenwood |
| Bruce Rindahl | Joe Conway | Robert Coup |
| Bruno Wolff III | Jonne Savolainen | Rodrigo Smarzaro |
| Bryce L. Nordgren | Jorge Gustavo Rocha | Roger Crew |
| Carl Anderson | Jorge Sanz | Ron Mayer |
| Carlos López Quintanilla | Jose Carlos Martinez Llari | Sam Peters |
| Charles Karney | Jostein Leira | Sergei Shoulbakov |
| Charlie Savage | Jörg Habenicht | Sergey Fedoseev |
| Chris Mayo | Juan Sebastian Jimenez Aldana | Shinichi Sugiyama |
| Christian Schroeder | Juergen E. Fischer | Shoaib Burq |
| Christoph Berg | Julien Monticolo | Silvio Grosso |
| Christoph Moench-Tegeder | Julien Rouhaud | Stefan Corneliu Petrea |
| Dan Faudemer | Kashif Rasul | Steffen Macke |
| Dan Levy | Klaus Foerster | Stepan Kuzmin |
| Dane Springmeyer | Kris Jurka | Stephen Frost |
| Daniel Nylander | Kristian Thy | Stephen Woodbridge |
| Dapeng Wang | Lars Aksel Opsahl | Steven Ottens |
| Daryl Herzmann | Laurențiu Nicola | Talha Rizwan |
| Dave Fuhry | Laurenz Albe | Temuri Doghonadze |
| David G. Johnston | Lars Roessiger | Teramoto Ikuhiro |
| David Garnier | Lauri Kajan | Thomas Muguet |
| David Skea | Leo Hsu | Thomas Petazzoni |
| David Techer | Loic Dachary | Tobias Bussmann |
| Denys Kovshun | Louis Descoteaux | Tom Glancy |
| Devrim Gündüz | Luca Delucchi | Tom van Tilburg |
| Dian M Fay | Luca S. Percich | Victor Collod |
| Dmitry Vasilyev | Lucas C. Villa Real | Vincent Bre |
| Edouard Choinière | Ludovic Hirlimann | Vincent Mora |
| Eduin Carrillo | Maksim Korotkov | Vincent Picavet |
| Egor Ivkov | Manuel Morillo | Volf Tomáš |
| Esteban Zimanyi | Maria Arias de Reyna | Yoichi Kayama |
| Eugene Antimirov | Marc Ducobu | Yuri Astrakhan |
| Evan Si | Mark Sondheim | Zuo Chenwei |
| Even Rouault | Markus Schaber |
These are corporate entities that have contributed developer time, hosting, or direct monetary funding to the PostGIS project. In alphabetical order:
Crowd funding campaigns are campaigns we run to get badly wanted features funded that can service a large number of people. Each campaign is specifically focused on a particular feature or set of features. Each sponsor chips in a small fraction of the needed funding and with enough people/organizations contributing, we have the funds to pay for the work that will help many. If you have an idea for a feature you think many others would be willing to co-fund, please post to the PostGIS newsgroup your thoughts and together we can make it happen.
PostGIS has experimented with community fundraising for features in the past. We used PledgeBank and we got two successful campaigns out of it.
postgistopology - 10 plus sponsors each contributed $250 USD to build toTopoGeometry function and beef up topology support in 2.0.0. It happened.
postgis64windows - 20 someodd sponsors each contributed $100 USD to pay for the work needed to work out PostGIS 64-bit issues on windows. It happened.
PostgreSQL, the extensible database system on which PostGIS is built. PostgreSQL provides the SQL engine, transactions, query planner, extension framework, and index access methods used by PostGIS.
The GEOS geometry operations library.
The PROJ coordinate transformation and geodesic calculation library.
The GDAL Geospatial Data Abstraction Library used to power much of the raster functionality introduced in PostGIS 2. In kind, improvements needed in GDAL to support PostGIS are contributed back to the GDAL project.
LibXML2 for XML-based spatial formats, and JSON-C for GeoJSON input.
The GNU Multiple Precision Arithmetic Library (GMP) for precision-sensitive topology operations.
protobuf-c for Mapbox Vector Tile and Geobuf output.
The iconv API, supplied by the C library or GNU libiconv, for character encoding conversion in the shapefile loader.
SFCGAL for advanced 2D and 3D functions, together with the CGAL algorithms that SFCGAL exposes.
PostGIS ships selected source from FlatGeobuf and FlatBuffers to support FlatGeobuf input and output.
Wagyu and Mapbox Geometry provide polygon clipping and validation for Mapbox Vector Tile output.
Ryu provides round-trip-safe floating-point formatting, and uthash provides in-process hash tables.
The shapefile loader and dumper include code derived from ShapeLib, originally by Frank Warmerdam and Even Rouault. They also include public-domain getopt code from AT&T.
liblwgeom/lookup3.c contains the public-domain lookup3 hash function by Bob Jenkins.
This version requires GEOS 3.10+, PostgreSQL 14-19beta1, Proj 6.1+, libgmp. To take advantage of all features postgis extension features, GEOS 3.15+ is needed. To take advantage of all postgis_sfcgal extension features SFCGAL 2.3+ is needed.
#5688, [topology] topology building functions now interpret tolerance 0 (old default) to really mean 0 and want -1 (new default) to mean "use topology precision" (Sandro Santilli)
#6024, Remove support for PostgreSQL 12 and 13 (Regina Obe)
#6040, ST_GeoHash round trip through ST_GeomFromGeoHash (Paul Ramsey)
#6053, [address_standardizer] Extension removed and moved to https://github.com/postgis/address_standardizer (Paul Ramsey)
#6052, [tiger_geocoder] Extension removed and moved to https://git.osgeo.org/postgis/postgis_tiger_geocoder (Regina Obe)
#6079, Remove support for GEOS < 3.10 (Sandro Santilli)
#1793, Remove ST_MemCollect aggregate (Darafei Praliaskouski)
GH-848, CG_AlphaShape now returns a MultiPolygon (Jean Felder)
#1124, #2935, #3033, #4658, #4659, [loader] Rework loader arguments: shp2pgsql can create UNLOGGED tables and choose the feature id column name, shp2pgsql --drop-table can emit DROP TABLE before prepare output, raster2pgsql/shp2pgsql expose loader actions as long options, both loaders accept long aliases for existing options, and
-if-not-exists makes creation actions idempotent (Darafei Praliaskouski)
#4208, Add single-geometry variants of ST_MaxDistance and ST_LongestLine (Darafei Praliaskouski)
[topology] FindVertexSegmentPairsBelowDistance function (Sandro Santilli)
ST_CoverageEdges, returns MultiLinestring of distinct shared edges in polygonal coverage (Paul Ramsey)
ST_MinimumSpanningTree, window function to calculate MST (Paul Ramsey)
#5993, [topology] Add max_edges parameter to TopoGeo_AddLinestring (Sandro Santilli)
#6001, support MultiLineString in ST_MakeLine (Paul Ramsey)
#2858, ST_MMin and ST_MMax (Paul Ramsey)
#5941, [raster] Support GDT_Float16 pixel type (Darafei Praliaskouski)
#5992, Optimize GiST index for repeated edge subdivision in topology (Darafei Praliaskouski)
#5702, Allow the compiler to detect the parallelism -flto=auto (Darafei Praliaskouski)
#4798, ST_AsGeoJSON warns about duplicate property keys (Darafei Praliaskouski)
#5950, Document POSTGIS_REGRESS_DB_OWNER for sandboxed regression roles (Darafei Praliaskouski)
#4332, Clarify the scope of several Function Reference categories (Darafei Praliaskouski)
#4222, [raster] ST_DumpAsPolygons honours PostgreSQL interrupts (Darafei Praliaskouski)
#5109, Document the meaning of topology.next_left_edge and topology.next_right_edge links (Darafei Praliaskouski)
#5889, [topology] Include representative locations in topology build errors (Darafei Praliaskouski)
#2614, Use GEOSPreparedDistance and caching to accelerate ST_DWithin (Paul Ramsey)
#6022, Document ST_AsMVTGeom tile-coordinate simplification (Darafei Praliaskouski)
GH-839, ST_Multi support for TIN and surfaces (Loïc Bartoletti)
#4398, Add ST_CatmullSmoothing smoothes but retains original vertices (Paul Ramsey)
#4560, ST_3DInterpolatePoint for M interpolation from XYZ inputs (Paul Ramsey)
#1291, ST_MakePolygon support for curved rings (Darafei Praliaskouski)
GT-270, Add NURBSCurve (Loïc Bartoletti)
#2863, Add ST_XSize, ST_YSize, ST_ZSize, and ST_MSize dimension helpers (Darafei Praliaskouski)
[fuzzers] Centralize OSS-Fuzz build/dependency logic in PostGIS scripts, prefer requested CXX over pg_config --cc for internal C++ checks, and make fuzzer linking/runtime dependency packaging portable (Darafei Praliaskouski)
#2045, pgsql2shp query dumps no longer require temporary table privileges (Darafei Praliaskouski)
#1577, [loader] Report unsupported .zip archive input before trying to open shapefile sidecar files (Darafei Praliaskouski)
#3158, Move geometry and geography typmod bit helpers out of the public liblwgeom header (Darafei Praliaskouski)
#4678, [raster] Move st_sum4ma neighborhood callback to C (Darafei Praliaskouski)
#2116, [raster] Add ST_Value nearest-neighbor boundary options (Darafei Praliaskouski)
#2804, #4315, [raster] Support two-argument ST_MapAlgebra callbacks and pass callback call data as actual arguments (Darafei Praliaskouski)
#2898, Document SQL function cost tiers for contributors
#6062, [topology] Stop using recursive snapping, for improved robustness (Sandro Santilli)
#6065, Improved winding order computation robustness for rings having collapsed elements (Sandro Santilli)
#3743, #4385, [raster loader] Document raster2pgsql -s FROM_SRID:SRID reprojection support and clarify index creation timing for append loads (Darafei Praliaskouski)
#2137, [raster] Reuse matching source raster overviews in raster2pgsql -l (Darafei Praliaskouski)
#4749, Use point-in-polygon predicate fast paths for point-only GeometryCollections (Darafei Praliaskouski)
#5532, Validate the manual against DocBook XMLSchema in check-xml (Darafei Praliaskouski)
#6087, Add a repository-owned CI status checker and static dashboard generator (Darafei Praliaskouski)
#2807, [raster] Preserve missing NODATA values in ST_MapAlgebra outputs (Darafei Praliaskouski)
#2832, [raster] Avoid padding single-tile raster2pgsql overviews when padding is not requested (Darafei Praliaskouski)
#2623, Generate a pgsql2shp GID field when exporting geometry-only shapefiles (Darafei Praliaskouski)
#2850, Preserve pgsql2shp numeric precision and scale in DBF metadata (Darafei Praliaskouski)
#2386, Add raster2pgsql man page (Darafei Praliaskouski)
Build PostgreSQL extension modules with `-fno-semantic-interposition` when available so LTO can optimize same-DSO calls to exported PostGIS entry points directly instead of routing through the module PLT; in a local PostgreSQL 18 `pgbench` microbenchmark over 100k four-point groups this reduced `ST_Collect` aggregate latency by about 4% (Darafei Praliaskouski)
#5973, Install PostGIS utilities under `pg_config --bindir` by default and document `pg_config`-derived install paths more accurately (Darafei Praliaskouski)
#2808, Clarify postgis_full_version() output when installed component scripts are newer than core scripts (Darafei Praliaskouski)
#5593, Docs: render manual images with GraphicsMagick without temporary files, enabling parallel builds, keeping ImageMagick fallbacks working, and documenting the generator workflow for contributors (Darafei Praliaskouski)
#5645, Docs: keep code operators ("=>") intact in translated manuals by enforcing verbatim CSS (Darafei Praliaskouski)
#1408, Docs: flatten transparent manual images onto white backgrounds for PDF builds while keeping HTML images transparent (Darafei Praliaskouski)
#2838, Emit valid X3D Coordinate nodes for 2D polygon output (Darafei Praliaskouski)
#1705, Infer constraint metadata for direct view and materialized view geometry columns (Darafei Praliaskouski)
GH-899, [raster] Honor PostgreSQL interrupts in long-running GDAL progress callbacks (Darafei Praliaskouski)
#2583, Preserve Z/ZM dimensional qualifiers in ST_AsEWKT output for TIN (Darafei Praliaskouski)