lwin_geojson.c

Go to the documentation of this file.

/**********************************************************************
 *
 * PostGIS - Spatial Types for PostgreSQL
 * http://postgis.net
 *
 * PostGIS is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * PostGIS is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with PostGIS.  If not, see <http://www.gnu.org/licenses/>.
 *
 **********************************************************************
 *
 * Copyright 2019 Darafei Praliaskouski <me@komzpa.net>
 * Copyright 2013 Sandro Santilli <strk@kbt.io>
 * Copyright 2011 Kashif Rasul <kashif.rasul@gmail.com>
 *
 **********************************************************************/
 
#include "liblwgeom.h"
#include "lwgeom_log.h"
#include "../postgis_config.h"
 
#if defined(HAVE_LIBJSON)
 
#define JSON_C_VERSION_013 (13 << 8)
 
#include <json.h>
 
#if !defined(JSON_C_VERSION_NUM) || JSON_C_VERSION_NUM < JSON_C_VERSION_013
#include <json_object_private.h>
#endif
 
#ifndef JSON_C_VERSION
/* Adds support for libjson < 0.10 */
#define json_tokener_error_desc(x) json_tokener_errors[(x)]
#endif
 
#include <string.h>
 
/* Prototype */
static LWGEOM *parse_geojson(json_object *geojson, int *hasz);
 
static inline json_object *
findMemberByName(json_object *poObj, const char *pszName)
{
        json_object *poTmp;
        json_object_iter it;
 
        poTmp = poObj;
 
        if (!pszName || !poObj)
                return NULL;
 
        it.key = NULL;
        it.val = NULL;
        it.entry = NULL;
 
        if (json_object_get_object(poTmp))
        {
                if (!json_object_get_object(poTmp)->head)
                {
                        lwerror("invalid GeoJSON representation");
                        return NULL;
                }
 
                for (it.entry = json_object_get_object(poTmp)->head;
                     (it.entry ? (it.key = (char *)it.entry->k, it.val = (json_object *)it.entry->v, it.entry) : 0);
                     it.entry = it.entry->next)
                {
                        if (strcasecmp((char *)it.key, pszName) == 0)
                                return it.val;
                }
        }
 
        return NULL;
}
 
static inline json_object *
parse_coordinates(json_object *geojson)
{
        json_object *coordinates = findMemberByName(geojson, "coordinates");
        if (!coordinates)
        {
                lwerror("Unable to find 'coordinates' in GeoJSON string");
                return NULL;
        }
 
        if (json_type_array != json_object_get_type(coordinates))
        {
                lwerror("The 'coordinates' in GeoJSON are not an array");
                return NULL;
        }
        return coordinates;
}
 
 
static inline int
parse_geojson_coord(json_object *poObj, int *hasz, POINTARRAY *pa)
{
        POINT4D pt = {0, 0, 0, 0};
 
        if (json_object_get_type(poObj) == json_type_array)
        {
                json_object *poObjCoord = NULL;
                const int nSize = json_object_array_length(poObj);
                if (nSize == 0)
                        return LW_TRUE;
                if (nSize < 2)
                {
                        lwerror("Too few ordinates in GeoJSON");
                        return LW_FAILURE;
                }
 
                /* Read X coordinate */
                poObjCoord = json_object_array_get_idx(poObj, 0);
                pt.x = json_object_get_double(poObjCoord);
 
                /* Read Y coordinate */
                poObjCoord = json_object_array_get_idx(poObj, 1);
                pt.y = json_object_get_double(poObjCoord);
 
                if (nSize > 2) /* should this be >= 3 ? */
                {
                        /* Read Z coordinate */
                        poObjCoord = json_object_array_get_idx(poObj, 2);
                        pt.z = json_object_get_double(poObjCoord);
                        *hasz = LW_TRUE;
                }
        }
        else
        {
                /* If it's not an array, just don't handle it */
                lwerror("The 'coordinates' in GeoJSON are not sufficiently nested");
                return LW_FAILURE;
        }
 
        return ptarray_append_point(pa, &pt, LW_TRUE);
}
 
static inline LWGEOM *
parse_geojson_point(json_object *geojson, int *hasz)
{
        json_object *coords = parse_coordinates(geojson);
        if (!coords)
                return NULL;
        POINTARRAY *pa = ptarray_construct_empty(1, 0, 1);
        parse_geojson_coord(coords, hasz, pa);
        return (LWGEOM *)lwpoint_construct(0, NULL, pa);
}
 
static inline LWGEOM *
parse_geojson_linestring(json_object *geojson, int *hasz)
{
        json_object *points = parse_coordinates(geojson);
        if (!points)
                return NULL;
        POINTARRAY *pa = ptarray_construct_empty(1, 0, 1);
        const int nPoints = json_object_array_length(points);
        for (int i = 0; i < nPoints; i++)
        {
                json_object *coords = json_object_array_get_idx(points, i);
                parse_geojson_coord(coords, hasz, pa);
        }
        return (LWGEOM *)lwline_construct(0, NULL, pa);
}
 
static inline LWPOLY *
parse_geojson_poly_rings(json_object *rings, int *hasz)
{
        if (!rings || json_object_get_type(rings) != json_type_array)
                return NULL;
 
        int nRings = json_object_array_length(rings);
 
        /* No rings => POLYGON EMPTY */
        if (!nRings)
                return lwpoly_construct_empty(0, 1, 0);
 
        /* Expecting up to nRings otherwise */
        POINTARRAY **ppa = (POINTARRAY **)lwalloc(sizeof(POINTARRAY *) * nRings);
        int o = 0;
 
        for (int i = 0; i < nRings; i++)
        {
                json_object *points = json_object_array_get_idx(rings, i);
                if (!points || json_object_get_type(points) != json_type_array)
                {
                        for (int k = 0; k < o; k++)
                                ptarray_free(ppa[k]);
                        lwfree(ppa);
                        lwerror("The 'coordinates' in GeoJSON ring are not an array");
                        return NULL;
                }
                int nPoints = json_object_array_length(points);
 
                /* Skip empty rings */
                if (!nPoints)
                {
                        /* Empty outer? Don't promote first hole to outer, holes don't matter. */
                        if (!i)
                                break;
                        else
                                continue;
                }
 
                ppa[o] = ptarray_construct_empty(1, 0, 1);
                for (int j = 0; j < nPoints; j++)
                {
                        json_object *coords = NULL;
                        coords = json_object_array_get_idx(points, j);
                        if (LW_FAILURE == parse_geojson_coord(coords, hasz, ppa[o]))
                        {
                                for (int k = 0; k <= o; k++)
                                        ptarray_free(ppa[k]);
                                lwfree(ppa);
                                lwerror("The 'coordinates' in GeoJSON are not sufficiently nested");
                                return NULL;
                        }
                }
                o++;
        }
 
        /* All the rings were empty! */
        if (!o)
        {
                lwfree(ppa);
                return lwpoly_construct_empty(0, 1, 0);
        }
 
        return lwpoly_construct(0, NULL, o, ppa);
}
 
static inline LWGEOM *
parse_geojson_polygon(json_object *geojson, int *hasz)
{
        return (LWGEOM *)parse_geojson_poly_rings(parse_coordinates(geojson), hasz);
}
 
static inline LWGEOM *
parse_geojson_multipoint(json_object *geojson, int *hasz)
{
        json_object *points = parse_coordinates(geojson);
        if (!points)
                return NULL;
        LWMPOINT *geom = (LWMPOINT *)lwcollection_construct_empty(MULTIPOINTTYPE, 0, 1, 0);
 
        const int nPoints = json_object_array_length(points);
        for (int i = 0; i < nPoints; ++i)
        {
                POINTARRAY *pa = ptarray_construct_empty(1, 0, 1);
                json_object *coord = json_object_array_get_idx(points, i);
                if (parse_geojson_coord(coord, hasz, pa))
                        geom = lwmpoint_add_lwpoint(geom, lwpoint_construct(0, NULL, pa));
                else
                {
                        lwmpoint_free(geom);
                        ptarray_free(pa);
                        return NULL;
                }
        }
 
        return (LWGEOM *)geom;
}
 
static inline LWGEOM *
parse_geojson_multilinestring(json_object *geojson, int *hasz)
{
        json_object *mls = parse_coordinates(geojson);
        if (!mls)
                return NULL;
        LWMLINE *geom = (LWMLINE *)lwcollection_construct_empty(MULTILINETYPE, 0, 1, 0);
        const int nLines = json_object_array_length(mls);
        for (int i = 0; i < nLines; ++i)
        {
                POINTARRAY *pa = ptarray_construct_empty(1, 0, 1);
                json_object *coords = json_object_array_get_idx(mls, i);
 
                if (json_type_array == json_object_get_type(coords))
                {
                        const int nPoints = json_object_array_length(coords);
                        for (int j = 0; j < nPoints; ++j)
                        {
                                json_object *coord = json_object_array_get_idx(coords, j);
                                if (!parse_geojson_coord(coord, hasz, pa))
                                {
                                        lwmline_free(geom);
                                        ptarray_free(pa);
                                        return NULL;
                                }
                        }
                        geom = lwmline_add_lwline(geom, lwline_construct(0, NULL, pa));
                }
                else
                {
                        lwmline_free(geom);
                        ptarray_free(pa);
                        return NULL;
                }
        }
        return (LWGEOM *)geom;
}
 
static inline LWGEOM *
parse_geojson_multipolygon(json_object *geojson, int *hasz)
{
        json_object *polys = parse_coordinates(geojson);
        if (!polys)
                return NULL;
        LWGEOM *geom = (LWGEOM *)lwcollection_construct_empty(MULTIPOLYGONTYPE, 0, 1, 0);
        int nPolys = json_object_array_length(polys);
 
        for (int i = 0; i < nPolys; ++i)
        {
                json_object *rings = json_object_array_get_idx(polys, i);
                LWPOLY *poly = parse_geojson_poly_rings(rings, hasz);
                if (poly)
                        geom = (LWGEOM *)lwmpoly_add_lwpoly((LWMPOLY *)geom, poly);
        }
 
        return geom;
}
 
static inline LWGEOM *
parse_geojson_geometrycollection(json_object *geojson, int *hasz)
{
        json_object *poObjGeoms = findMemberByName(geojson, "geometries");
        if (!poObjGeoms)
        {
                lwerror("Unable to find 'geometries' in GeoJSON string");
                return NULL;
        }
        LWGEOM *geom = (LWGEOM *)lwcollection_construct_empty(COLLECTIONTYPE, 0, 1, 0);
 
        if (json_type_array == json_object_get_type(poObjGeoms))
        {
                const int nGeoms = json_object_array_length(poObjGeoms);
                for (int i = 0; i < nGeoms; ++i)
                {
                        json_object *poObjGeom = json_object_array_get_idx(poObjGeoms, i);
                        LWGEOM *t = parse_geojson(poObjGeom, hasz);
                        if (t)
                                geom = (LWGEOM *)lwcollection_add_lwgeom((LWCOLLECTION *)geom, t);
                        else
                        {
                                lwgeom_free(geom);
                                return NULL;
                        }
                }
        }
 
        return geom;
}
 
static inline LWGEOM *
parse_geojson(json_object *geojson, int *hasz)
{
        json_object *type = NULL;
        const char *name;
 
        if (!geojson)
        {
                lwerror("invalid GeoJSON representation");
                return NULL;
        }
 
        type = findMemberByName(geojson, "type");
        if (!type)
        {
                lwerror("unknown GeoJSON type");
                return NULL;
        }
 
        name = json_object_get_string(type);
 
        if (strcasecmp(name, "Point") == 0)
                return parse_geojson_point(geojson, hasz);
 
        if (strcasecmp(name, "LineString") == 0)
                return parse_geojson_linestring(geojson, hasz);
 
        if (strcasecmp(name, "Polygon") == 0)
                return parse_geojson_polygon(geojson, hasz);
 
        if (strcasecmp(name, "MultiPoint") == 0)
                return parse_geojson_multipoint(geojson, hasz);
 
        if (strcasecmp(name, "MultiLineString") == 0)
                return parse_geojson_multilinestring(geojson, hasz);
 
        if (strcasecmp(name, "MultiPolygon") == 0)
                return parse_geojson_multipolygon(geojson, hasz);
 
        if (strcasecmp(name, "GeometryCollection") == 0)
                return parse_geojson_geometrycollection(geojson, hasz);
 
        lwerror("invalid GeoJson representation");
        return NULL; /* Never reach */
}
 
#endif /* HAVE_LIBJSON */
 
LWGEOM *
lwgeom_from_geojson(const char *geojson, char **srs)
{
#ifndef HAVE_LIBJSON
        *srs = NULL;
        lwerror("You need JSON-C for lwgeom_from_geojson");
        return NULL;
#else  /* HAVE_LIBJSON */
 
        /* Begin to Parse json */
        json_tokener *jstok = json_tokener_new();
        json_object *poObj = json_tokener_parse_ex(jstok, geojson, -1);
        if (jstok->err != json_tokener_success)
        {
                char err[256];
                snprintf(err, 256, "%s (at offset %d)", json_tokener_error_desc(jstok->err), jstok->char_offset);
                json_tokener_free(jstok);
                json_object_put(poObj);
                lwerror(err);
                return NULL;
        }
        json_tokener_free(jstok);
 
        *srs = NULL;
        json_object *poObjSrs = findMemberByName(poObj, "crs");
        if (poObjSrs != NULL)
        {
                json_object *poObjSrsType = findMemberByName(poObjSrs, "type");
                if (poObjSrsType != NULL)
                {
                        json_object *poObjSrsProps = findMemberByName(poObjSrs, "properties");
                        if (poObjSrsProps)
                        {
                                json_object *poNameURL = findMemberByName(poObjSrsProps, "name");
                                if (poNameURL)
                                {
                                        const char *pszName = json_object_get_string(poNameURL);
                                        if (pszName)
                                        {
                                                *srs = lwalloc(strlen(pszName) + 1);
                                                strcpy(*srs, pszName);
                                        }
                                }
                        }
                }
        }
 
        int hasz = LW_FALSE;
        LWGEOM *lwgeom = parse_geojson(poObj, &hasz);
        json_object_put(poObj);
        if (!lwgeom)
                return NULL;
 
        if (!hasz)
        {
                LWGEOM *tmp = lwgeom_force_2d(lwgeom);
                lwgeom_free(lwgeom);
                lwgeom = tmp;
        }
        lwgeom_add_bbox(lwgeom);
        return lwgeom;
#endif /* HAVE_LIBJSON */
}