PHPackages                             brick/geo - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Utility & Helpers](/categories/utility)
4. /
5. brick/geo

ActiveLibrary[Utility & Helpers](/categories/utility)

brick/geo
=========

GIS geometry library

0.13.1(1y ago)245862.1k↑13.2%33[6 issues](https://github.com/brick/geo/issues)[1 PRs](https://github.com/brick/geo/pulls)12MITPHPPHP ^8.1CI passing

Since Oct 3Pushed 1mo ago12 watchersCompare

[ Source](https://github.com/brick/geo)[ Packagist](https://packagist.org/packages/brick/geo)[ GitHub Sponsors](https://github.com/BenMorel)[ RSS](/packages/brick-geo/feed)WikiDiscussions main Synced 1mo ago

READMEChangelog (10)Dependencies (4)Versions (39)Used By (12)

Brick\\Geo
==========

[](#brickgeo)

[![](https://raw.githubusercontent.com/brick/brick/master/logo.png)](https://raw.githubusercontent.com/brick/brick/master/logo.png)

A GIS geometry library for PHP.

[![Build Status](https://github.com/brick/geo/workflows/CI/badge.svg)](https://github.com/brick/geo/actions)[![Coverage Status](https://camo.githubusercontent.com/72c51f12863c1c8a49e3788fd708d2a3670f717421261d5959728016c47241e0/68747470733a2f2f636f6465636f762e696f2f6769746875622f627269636b2f67656f2f67726170682f62616467652e737667)](https://codecov.io/github/brick/geo)[![Latest Stable Version](https://camo.githubusercontent.com/50e15ca52cfa5d04971898044f09c520e05fdfe07652d43228ecc6c3bd14e2db/68747470733a2f2f706f7365722e707567782e6f72672f627269636b2f67656f2f762f737461626c65)](https://packagist.org/packages/brick/geo)[![Total Downloads](https://camo.githubusercontent.com/dcc27dc1358372c1568464adf3e9fe18ee01c8b2fb6b40f576c3edd95889a45a/68747470733a2f2f706f7365722e707567782e6f72672f627269636b2f67656f2f646f776e6c6f616473)](https://packagist.org/packages/brick/geo)[![License](https://camo.githubusercontent.com/7013272bd27ece47364536a221edb554cd69683b68a46fc0ee96881174c4214c/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f6c6963656e73652d4d49542d626c75652e737667)](http://opensource.org/licenses/MIT)

Introduction
------------

[](#introduction)

This library is a PHP implementation of the [OpenGIS specification](http://www.opengeospatial.org/standards/sfa).

It provides [Geometry classes](#geometry-hierarchy) (`Point`, `LineString`, `Polygon`, etc.), and can natively read/write many formats: WKB, WKT, EWKB, EWKT, and GeoJSON.

It also provides a `GeometryEngine` interface for advanced calculations (`length`, `area`, `union`, `intersection`, etc.), together with implementations that delegate these operations to a third-party GIS engine:

- the [**GEOS**](https://git.osgeo.org/gitea/geos/php-geos) extension,
- the [**geosop**](https://libgeos.org/usage/tools/#geosop) command-line tool,
- or a GIS-enabled database:
    - **MySQL**
    - **MariaDB**
    - **PostgreSQL** with the **PostGIS** extension
    - **SQLite** with the **SpatiaLite** extension

Requirements and installation
-----------------------------

[](#requirements-and-installation)

This library requires PHP 8.1. For PHP 8.0, you can use version `0.9`. For PHP 7.4, you can use version `0.7`.

Install the library with [Composer](https://getcomposer.org/):

```
composer require brick/geo
```

If you only need basic operations such as building Geometry objects, importing from / exporting to one of the supported formats (WKB, WKT, EWKB, EWKT, or GeoJSON), then you're all set.

If you need advanced features, such as `length()`, `union()`, `intersection`, etc., head on to the [Configuration](#configuration) section to choose a `GeometryEngine` implementation.

Project status & release process
------------------------------------

[](#project-status--release-process)

This library is still under development.

The current releases are numbered `0.x.y`. When a non-breaking change is introduced (adding new methods, optimizing existing code, etc.), `y` is incremented.

**When a breaking change is introduced, a new `0.x` version cycle is always started.**

It is therefore safe to lock your project to a given release cycle, such as `0.13.*`.

If you need to upgrade to a newer release cycle, check the [release history](https://github.com/brick/geo/releases) for a list of changes introduced by each further `0.x.0` version.

Quick start
-----------

[](#quick-start)

```
use Brick\Geo\LineString;
use Brick\Geo\Point;
use Brick\Geo\Polygon;

// Building geometries from coordinates

$lineString = LineString::of(
    Point::xy(1, 2),
    Point::xy(3, 4),
);

echo $lineString->asText(); // LINESTRING (1 2, 3 4)

// Importing geometries

$point = Point::fromText('POINT (1 2)');

echo $point->x(); // 1
echo $point->y(); // 2

// Using advanced calculations from a GeometryEngine
// (see the Configuration section)

$polygon = Polygon::fromText('POLYGON ((0 0, 0 3, 3 3, 0 0))');
echo $geometryEngine->area($polygon); // 4.5

$centroid = $geometryEngine->centroid($polygon);
echo $centroid->asText(); // POINT (1 2)
```

Configuration
-------------

[](#configuration)

Advanced calculations are available through the `GeometryEngine` interface. The library ships with the following implementations:

- `PdoEngine`: communicates with a GIS-compatible database over a `PDO` connection.
    This engine currently supports the following databases:
    - [MySQL](http://php.net/manual/en/ref.pdo-mysql.php) version 5.6 or greater (*2D geometries only*)
    - MariaDB version 5.5 or greater
    - [PostgreSQL](http://php.net/manual/en/ref.pdo-pgsql.php) with the [PostGIS](http://postgis.net/) extension
- `Sqlite3Engine`: communicates with an [SQLite3](http://php.net/manual/en/book.sqlite3.php) database with the [SpatiaLite](https://www.gaia-gis.it/fossil/libspatialite/index) extension
- `GeosEngine`: uses the [GEOS](https://git.osgeo.org/gitea/geos/php-geos) PHP extension
- `GeosOpEngine`: uses the [geosop](https://libgeos.org/usage/tools/#geosop) command-line tool

Your choice for the right implementation should be guided by two criteria:

- **availability**: if you already use a GIS-enabled database such as MySQL, this may be an easy choice;
- **capabilities**: not all databases offer the same GIS capabilities:
    - some functions may be available on PostgreSQL but not on other databases (see the [GeometryEngine methods reference](#geometryengine-methods-reference) section)
    - some functions may be restricted to certain geometry types and/or SRIDs; for example, `buffer()` works on MySQL, but would fail with a `Polygon` on SRID 4326 (GPS coordinates, distance in meters)
    - some databases may return distances in meters on SRID 4326, while others may return distances in degrees

You should probably start with the easiest method that works for you, and test if this setup matches your expectations.

Click on one of the following configurations to see the setup instructions:

Using **PDO** and **MySQL**- Ensure that your MySQL version is at least `5.6`.
    Earlier versions only have partial GIS support based on bounding boxes and are not supported.
- Use this bootstrap code in your project:

    ```
    use Brick\Geo\Engine\PdoEngine;

    $pdo = new PDO('mysql:host=localhost', 'root', '');
    $geometryEngine = new PdoEngine($pdo);
    ```

Update the code with your own connection parameters, or use an existing `PDO` connection if you have one (recommended).

Using **PDO** and **MariaDB**- Ensure that your MariaDB version is at least `5.5`.
- MariaDB is a fork of MySQL, so you can follow the same procedure as for MySQL.

Using **PDO** and **PostgreSQL** with **PostGIS**- Ensure that [PostGIS is installed](http://postgis.net/install/) on your server
- Enable PostGIS on the database server if needed:

    ```
      CREATE EXTENSION postgis;

    ```
- Use this bootstrap code in your project:

    ```
    use Brick\Geo\Engine\PdoEngine;

    $pdo = new PDO('pgsql:host=localhost', 'postgres', '');
    $geometryEngine = new PdoEngine($pdo);
    ```

Update the code with your own connection parameters, or use an existing `PDO` connection if you have one (recommended).

Using **PDO** and **SQLite** with **SpatiaLite**Due to [limitations in the pdo\_sqlite driver](https://bugs.php.net/bug.php?id=64810), it is currently not possible\* to load the SpatiaLite extension with a `SELECT LOAD_EXTENSION()` query, hence you cannot use SpatiaLite with the PDO driver.

You need to use the SQLite3 driver instead. Note that you can keep using your existing PDO SQLite code, all you need to do is create an additional in-memory SQLite3 database just to power the geometry engine.

\* It actually *is* possible, using [moxio/sqlite-extended-api](https://github.com/Moxio/sqlite-extended-api), which uses FFI and [Z-Engine](https://github.com/lisachenko/z-engine), but beware that this library is still experimental!

Using **SQLite3** with **SpatiaLite**- Ensure that [SpatiaLite is installed](https://www.gaia-gis.it/fossil/libspatialite/index) on your system.
- Ensure that the SQLite3 extension is enabled in your `php.ini`:

    ```
      extension=sqlite3.so

    ```
- Ensure that the SQLite3 extension dir where SpatiaLite is installed is configured in your `php.ini`:

    ```
      [sqlite3]
      sqlite3.extension_dir = /usr/lib

    ```
- Use this bootstrap code in your project:

    ```
    use Brick\Geo\Engine\Sqlite3Engine;

    $sqlite3 = new SQLite3(':memory:');
    $sqlite3->loadExtension('mod_spatialite.so');
    $geometryEngine = new Sqlite3Engine($sqlite3);
    ```
- Depending on the functions you use, you will probably need to initialize the spatial metadata by running this query:

    ```
    SELECT InitSpatialMetaData();
    ```

    You only need to run this query once if your database is persisted, but **if your database is in-memory, you'll need to run it on every connection**. Be aware that this may hurt performance.

In this example we have created an in-memory database for our GIS calculations, but you can also use an existing `SQLite3` connection.

Using the **GEOS** extension- Ensure that the [GEOS extension](https://git.osgeo.org/gitea/geos/php-geos) is installed on your server (GEOS 3.6.0 onwards; previous versions require compiling GEOS with the `--enable-php` flag).
- Ensure that the extension is enabled in your `php.ini`:

    ```
      extension=geos.so

    ```
- Use this bootstrap code in your project:

    ```
    use Brick\Geo\Engine\GeosEngine;

    $geometryEngine = new GeosEngine();
    ```

Using the **`geosop`** command-line tool- Ensure that [geosop](https://libgeos.org/usage/tools/#geosop) is installed on your server. You can install it on Fedora / RHEL (with EPEL) with the `geos` package, or on Ubuntu / Debian with the `geos-bin` package.
- Use this bootstrap code in your project:

    ```
    use Brick\Geo\Engine\GeosOpEngine;

    $geometryEngine = new GeosOpEngine('/usr/bin/geosop');
    ```

Adjust the path to the `geosop` binary if needed.

Note that every call to the `GeosOpEngine` will spawn a new process, which comes with a performance overhead compared to the other engines.

Geometry hierarchy
------------------

[](#geometry-hierarchy)

All geometry objects reside in the `Brick\Geo` namespace, and extend a base `Geometry` class:

- [Geometry](https://github.com/brick/geo/blob/master/src/Geometry.php) `abstract`
    - [Point](https://github.com/brick/geo/blob/master/src/Point.php)
    - [Curve](https://github.com/brick/geo/blob/master/src/Curve.php) `abstract`
        - [LineString](https://github.com/brick/geo/blob/master/src/LineString.php)
        - [CompoundCurve](https://github.com/brick/geo/blob/master/src/CompoundCurve.php)
        - [CircularString](https://github.com/brick/geo/blob/master/src/CircularString.php)
    - [Surface](https://github.com/brick/geo/blob/master/src/Surface.php) `abstract`
        - [Polygon](https://github.com/brick/geo/blob/master/src/Polygon.php)
            - [Triangle](https://github.com/brick/geo/blob/master/src/Triangle.php)
        - [CurvePolygon](https://github.com/brick/geo/blob/master/src/CurvePolygon.php)
        - [PolyhedralSurface](https://github.com/brick/geo/blob/master/src/PolyhedralSurface.php)
            - [Tin](https://github.com/brick/geo/blob/master/src/Tin.php)
    - [GeometryCollection](https://github.com/brick/geo/blob/master/src/GeometryCollection.php)
        - [MultiPoint](https://github.com/brick/geo/blob/master/src/MultiPoint.php)
        - [MultiCurve](https://github.com/brick/geo/blob/master/src/MultiCurve.php) `abstract`
            - [MultiLineString](https://github.com/brick/geo/blob/master/src/MultiLineString.php)
        - [MultiSurface](https://github.com/brick/geo/blob/master/src/MultiSurface.php) `abstract`
            - [MultiPolygon](https://github.com/brick/geo/blob/master/src/MultiPolygon.php)

Geometry exceptions
-------------------

[](#geometry-exceptions)

All geometry exceptions reside in the `Brick\Geo\Exception` namespace, and extend a base `GeometryException` object.

Geometry exceptions are fine-grained: only subclasses of the base `GeometryException` class are thrown throughout the project. This leaves to the user the choice to catch only specific exceptions, or all geometry-related exceptions.

Here is a list of all exceptions:

- `CoordinateSystemException` is thrown when mixing objects with different SRID or dimensionality (e.g. XY with XYZ)
- `EmptyGeometryException` is thrown when trying to access a non-existent property on an empty geometry
- `GeometryEngineException` is thrown when a functionality is not supported by the current geometry engine
- `GeometryIoException` is thrown when an error occurs while reading or writing (E)WKB/T or GeoJSON data
- `InvalidGeometryException` is thrown when creating an invalid geometry, such as a `LineString` with only one `Point`
- `NoSuchGeometryException` is thrown when attempting to get a geometry at a non-existing index in a collection
- `UnexpectedGeometryException` is thrown when a geometry is not an instance of the expected subtype, for example when calling `Point::fromText()` with a `LineString` WKT.

GeometryEngine methods reference
--------------------------------

[](#geometryengine-methods-reference)

This is a list of all methods available in the `GeometryEngine` interface. Some methods are only available if you use a specific geometry engine, sometimes with a minimum version.

Function NameGEOSgeosopPostGISMySQLMariaDBSpatiaLite`area`✓✓✓✓✓`azimuth`✓✓`boundary`✓✓✓✓`buffer`✓✓✓✓✓✓`centroid`✓✓✓✓✓✓`contains`✓✓✓✓✓✓`concaveHull`✓✓✓`convexHull`✓✓✓5.7.6✓`crosses`✓3.12.0✓✓✓✓`difference`✓✓✓✓✓✓`disjoint`✓3.12.0✓✓✓✓`distance`✓✓✓✓✓✓`envelope`✓3.12.0✓✓✓✓`equals`✓3.11.0✓✓✓✓`intersection`✓✓✓✓✓✓`intersects`✓✓✓✓✓✓`isClosed`✓✓✓✓✓`isRing`✓✓✓✓✓`isSimple`✓✓✓✓✓✓`isValid`✓✓✓5.7.6✓`length`✓✓✓✓✓✓`lineInterpolatePoint`✓✓8.0.24✓`lineInterpolatePoints`✓8.0.24`locateAlong`✓✓`locateBetween`✓✓`makeValid`✓✓✓`maxDistance`✓✓`overlaps`✓3.12.0✓✓✓✓`pointOnSurface`✓✓✓`relate`✓✓✓`simplify`✓✓5.7.64.1.0`snapToGrid`✓✓`split`✓✓`symDifference`✓✓✓✓✓✓`touches`✓3.12.0✓✓✓✓`transform`✓✓8.0.13✓✓`union`✓✓✓✓✓✓`within`✓3.12.0✓✓✓✓Importing and exporting geometries
----------------------------------

[](#importing-and-exporting-geometries)

This library supports importing from and exporting to the following formats:

- WKT
- WKB
- EWKT
- EWKB
- GeoJSON

### WKT

[](#wkt)

Well-Known Text is the standard text format for geometries.

Every Geometry class provides a convenience method `fromText()`, that accepts a WKT string and an optional SRID, and returns a Geometry object:

```
use Brick\Geo\Point;

$point = Point::fromText('POINT (1.5 2.5)', 4326);
```

Geometries can be converted to WKT using the convenience method `asText()`:

```
echo $point->asText(); // POINT (1.5 2.5)
```

You can alternatively use the [WktReader](https://github.com/brick/geo/blob/master/src/Io/WktReader.php) and [WktWriter](https://github.com/brick/geo/blob/master/src/Io/WktWriter.php) classes directly; the latter allows you to pretty-print the output.

### WKB

[](#wkb)

Well-Known Binary is the standard binary format for geometries.

Every Geometry class provides a convenience method `fromBinary()`, that accepts a WKB binary string and an optional SRID, and returns a Geometry object:

```
use Brick\Geo\Point;

$point = Point::fromBinary(hex2bin('0101000000000000000000f83f0000000000000440'), 4326);

echo $point->asText(); // POINT (1.5 2.5)
echo $point->srid(); // 4326
```

Geometries can be converted to WKB using the convenience method `asBinary()`:

```
echo bin2hex($point->asBinary()); // 0101000000000000000000f83f0000000000000440
```

You can alternatively use the [WkbReader](https://github.com/brick/geo/blob/master/src/Io/WkbReader.php) and [WkbWriter](https://github.com/brick/geo/blob/master/src/Io/WkbWriter.php) classes directly; the latter allows you to choose the endianness of the output (big endian or little endian).

### EWKT

[](#ewkt)

Extended WKT is a PostGIS-specific text format that includes the SRID of the geometry object, which is missing from the standard WKT format. You can import from and export to this format using the [EwktReader](https://github.com/brick/geo/blob/master/src/Io/EwktReader.php) and [EwktWriter](https://github.com/brick/geo/blob/master/src/Io/EwktWriter.php) classes:

```
use Brick\Geo\Point;
use Brick\Geo\Io\EwktReader;
use Brick\Geo\Io\EwktWriter;

$reader = new EwktReader();
$point = $reader->read('SRID=4326; POINT (1.5 2.5)');

echo $point->asText(); // POINT (1.5 2.5)
echo $point->srid(); // 4326

$writer = new EwktWriter();
echo $writer->write($point); // SRID=4326; POINT (1.5 2.5)
```

### EWKB

[](#ewkb)

Extended WKB is a PostGIS-specific binary format that includes the SRID of the geometry object, which is missing from the standard WKB format. You can import from and export to this format using the [EwkbReader](https://github.com/brick/geo/blob/master/src/Io/EwkbReader.php) and [EwkbWriter](https://github.com/brick/geo/blob/master/src/Io/EwkbWriter.php) classes:

```
use Brick\Geo\Point;
use Brick\Geo\Io\EwkbReader;
use Brick\Geo\Io\EwkbWriter;

$reader = new EwkbReader();
$point = $reader->read(hex2bin('0101000020e6100000000000000000f83f0000000000000440'));

echo $point->asText(); // POINT (1.5 2.5)
echo $point->srid(); // 4326

$writer = new EwkbWriter();
echo bin2hex($writer->write($point)); // 0101000020e6100000000000000000f83f0000000000000440
```

### GeoJSON

[](#geojson)

GeoJSON is an open standard format designed for representing simple geographical features, based on JSON, and standardized in [RFC 7946](https://tools.ietf.org/html/rfc7946).

This library supports importing geometries from, and exporting them to GeoJSON documents using the [GeoJsonReader](https://github.com/brick/geo/blob/master/src/Io/GeoJsonReader.php) and [GeoJsonWriter](https://github.com/brick/geo/blob/master/src/Io/GeoJsonWriter.php) classes:

```
use Brick\Geo\Point;
use Brick\Geo\Io\GeoJsonReader;
use Brick\Geo\Io\GeoJsonWriter;

$reader = new GeoJsonReader();
$point = $reader->read('{ "type": "Point", "coordinates": [1, 2] }');

echo $point->asText(); // POINT (1 2)
echo $point->srid(); // 4326

$writer = new GeoJsonWriter();
echo $writer->write($point); // {"type":"Point","coordinates":[1,2]}
```

The library supports reading and writing `Feature` and `FeatureCollection` objects, together with custom properties.

GeoJSON aims to support WGS84 only, and as such all Geometries are imported using [SRID 4326](https://epsg.io/4326).

Reducing coordinate precision
-----------------------------

[](#reducing-coordinate-precision)

Before exporting geometries in a text format, you may need to reduce the precision of the coordinates to keep the output small, while retaining a sufficient precision. You can use the `withRoundedCoordinates()` method for this:

```
use Brick\Geo\Point;
use Brick\Geo\Projector\RoundCoordinatesProjector;

$point = Point::xy(1.2345678, 2.3456789);
echo $point->asText(); // POINT (1.2345678 2.3456789)

$roundedPoint = $point->withRoundedCoordinates(2);
echo $roundedPoint->asText(); // POINT (1.23 2.35)
```

Doctrine mappings
-----------------

[](#doctrine-mappings)

You can use `brick/geo` types in your Doctrine entities using the [brick/geo-doctrine](https://github.com/brick/geo-doctrine) package.

###  Health Score

62

—

FairBetter than 99% of packages

Maintenance70

Regular maintenance activity

Popularity59

Moderate usage in the ecosystem

Community32

Small or concentrated contributor base

Maturity74

Established project with proven stability

 Bus Factor1

Top contributor holds 96.5% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Every ~80 days

Recently: every ~4 days

Total

35

Last Release

418d ago

PHP version history (7 changes)0.1.0PHP >=5.6

0.2.0PHP >=7.1

0.3.0PHP ^7.2 || ^8.0

0.6.0PHP ^7.4 || ^8.0

0.8.0PHP ^8.0

0.10.0PHP ^8.1

v0.14.x-devPHP ^8.2

### Community

Maintainers

![](https://www.gravatar.com/avatar/57189121968030f0770811b461cc92f9c19c08f5c4767292f2ede48b7277cfad?d=identicon)[BenMorel](/maintainers/BenMorel)

---

Top Contributors

[![BenMorel](https://avatars.githubusercontent.com/u/1952838?v=4)](https://github.com/BenMorel "BenMorel (820 commits)")[![cevou](https://avatars.githubusercontent.com/u/1201681?v=4)](https://github.com/cevou "cevou (22 commits)")[![Kolyunya](https://avatars.githubusercontent.com/u/2682768?v=4)](https://github.com/Kolyunya "Kolyunya (4 commits)")[![michaelcurry](https://avatars.githubusercontent.com/u/2658933?v=4)](https://github.com/michaelcurry "michaelcurry (1 commits)")[![Copilot](https://avatars.githubusercontent.com/in/1143301?v=4)](https://github.com/Copilot "Copilot (1 commits)")[![arminwinkt](https://avatars.githubusercontent.com/u/20049190?v=4)](https://github.com/arminwinkt "arminwinkt (1 commits)")[![gbuckingham89](https://avatars.githubusercontent.com/u/1455253?v=4)](https://github.com/gbuckingham89 "gbuckingham89 (1 commits)")

---

Tags

geometrygisphpbrickgeometrygeographygisgeo

###  Code Quality

TestsPHPUnit

Static AnalysisPsalm

Type Coverage Yes

### Embed Badge

![Health badge](/badges/brick-geo/health.svg)

```
[![Health](https://phpackages.com/badges/brick-geo/health.svg)](https://phpackages.com/packages/brick-geo)
```

###  Alternatives

[mjaschen/phpgeo

Simple Yet Powerful Geo Library

1.6k8.6M22](/packages/mjaschen-phpgeo)[martin-georgiev/postgresql-for-doctrine

Extends Doctrine with native PostgreSQL support for arrays, JSONB, ranges, PostGIS geometries, text search, ltree, uuid, and 100+ PostgreSQL-specific functions.

4485.3M4](/packages/martin-georgiev-postgresql-for-doctrine)[geokit/geokit

Geo-Toolkit for PHP

251924.7k6](/packages/geokit-geokit)[jsor/doctrine-postgis

Spatial and Geographic Data with PostGIS and Doctrine.

2191.6M1](/packages/jsor-doctrine-postgis)[geo-io/interface

Geo I/O base interfaces.

626.1M7](/packages/geo-io-interface)[matthiasmullie/geo

Geography helper

6377.6k1](/packages/matthiasmullie-geo)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)