lwcollection.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 (C) 2001-2006 Refractions Research Inc.
 *
 **********************************************************************/
 
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "liblwgeom_internal.h"
#include "lwgeom_log.h"
 
 
#define CHECK_LWGEOM_ZM 1
 
void
lwcollection_release(LWCOLLECTION *lwcollection)
{
        lwgeom_release(lwcollection_as_lwgeom(lwcollection));
}
 
LWCOLLECTION *
lwcollection_construct(uint8_t type, int32_t srid, GBOX *bbox, uint32_t ngeoms, LWGEOM **geoms)
{
        LWCOLLECTION *ret;
        int hasz, hasm;
#ifdef CHECK_LWGEOM_ZM
        char zm;
        uint32_t i;
#endif
 
        LWDEBUGF(2, "lwcollection_construct called with %d, %d, %p, %d, %p.", type, srid, bbox, ngeoms, geoms);
 
        if( ! lwtype_is_collection(type) )
                lwerror("Non-collection type specified in collection constructor!");
 
        hasz = 0;
        hasm = 0;
        if ( ngeoms > 0 )
        {
                hasz = FLAGS_GET_Z(geoms[0]->flags);
                hasm = FLAGS_GET_M(geoms[0]->flags);
#ifdef CHECK_LWGEOM_ZM
                zm = FLAGS_GET_ZM(geoms[0]->flags);
 
                LWDEBUGF(3, "lwcollection_construct type[0]=%d", geoms[0]->type);
 
                for (i=1; i<ngeoms; i++)
                {
                        LWDEBUGF(3, "lwcollection_construct type=[%d]=%d", i, geoms[i]->type);
 
                        if ( zm != FLAGS_GET_ZM(geoms[i]->flags) )
                                lwerror("lwcollection_construct: mixed dimension geometries: %d/%d", zm, FLAGS_GET_ZM(geoms[i]->flags));
                }
#endif
        }
 
 
        ret = lwalloc(sizeof(LWCOLLECTION));
        ret->type = type;
        ret->flags = lwflags(hasz,hasm,0);
        FLAGS_SET_BBOX(ret->flags, bbox?1:0);
        ret->srid = srid;
        ret->ngeoms = ngeoms;
        ret->maxgeoms = ngeoms;
        ret->geoms = geoms;
        ret->bbox = bbox;
 
        return ret;
}
 
LWCOLLECTION *
lwcollection_construct_empty(uint8_t type, int32_t srid, char hasz, char hasm)
{
        LWCOLLECTION *ret;
 
        if( ! lwtype_is_collection(type) )
        {
                lwerror("Non-collection type specified in collection constructor!");
                return NULL;
        }
 
        ret = lwalloc(sizeof(LWCOLLECTION));
        ret->type = type;
        ret->flags = lwflags(hasz,hasm,0);
        ret->srid = srid;
        ret->ngeoms = 0;
        ret->maxgeoms = 1; /* Allocate room for sub-members, just in case. */
        ret->geoms = lwalloc(ret->maxgeoms * sizeof(LWGEOM*));
        ret->bbox = NULL;
 
        return ret;
}
 
const LWGEOM *
lwcollection_getsubgeom(LWCOLLECTION *col, uint32_t gnum)
{
        return (const LWGEOM *)col->geoms[gnum];
}
 
LWCOLLECTION *
lwcollection_clone(const LWCOLLECTION *g)
{
        uint32_t i;
        LWCOLLECTION *ret = lwalloc(sizeof(LWCOLLECTION));
        memcpy(ret, g, sizeof(LWCOLLECTION));
        if ( g->ngeoms > 0 )
        {
                ret->geoms = lwalloc(sizeof(LWGEOM *)*g->ngeoms);
                for (i=0; i<g->ngeoms; i++)
                {
                        ret->geoms[i] = lwgeom_clone(g->geoms[i]);
                }
                if ( g->bbox ) ret->bbox = gbox_copy(g->bbox);
        }
        else
        {
                ret->bbox = NULL; /* empty collection */
                ret->geoms = NULL;
        }
        return ret;
}
 
LWCOLLECTION *
lwcollection_clone_deep(const LWCOLLECTION *g)
{
        uint32_t i;
        LWCOLLECTION *ret = lwalloc(sizeof(LWCOLLECTION));
        memcpy(ret, g, sizeof(LWCOLLECTION));
        if ( g->ngeoms > 0 )
        {
                ret->geoms = lwalloc(sizeof(LWGEOM *)*g->ngeoms);
                for (i=0; i<g->ngeoms; i++)
                {
                        ret->geoms[i] = lwgeom_clone_deep(g->geoms[i]);
                }
                if ( g->bbox ) ret->bbox = gbox_copy(g->bbox);
        }
        else
        {
                ret->bbox = NULL; /* empty collection */
                ret->geoms = NULL;
        }
        return ret;
}
 
void lwcollection_reserve(LWCOLLECTION *col, uint32_t ngeoms)
{
        if ( ngeoms <= col->maxgeoms ) return;
 
        /* Allocate more space if we need it */
        do { col->maxgeoms *= 2; } while ( col->maxgeoms < ngeoms );
        col->geoms = lwrealloc(col->geoms, sizeof(LWGEOM*) * col->maxgeoms);
}
 
LWCOLLECTION* lwcollection_add_lwgeom(LWCOLLECTION *col, const LWGEOM *geom)
{
        if (!col || !geom) return NULL;
 
        if (!col->geoms && (col->ngeoms || col->maxgeoms))
        {
                lwerror("Collection is in inconsistent state. Null memory but non-zero collection counts.");
                return NULL;
        }
 
        /* Check type compatibility */
        if ( ! lwcollection_allows_subtype(col->type, geom->type) ) {
                lwerror("%s cannot contain %s element", lwtype_name(col->type), lwtype_name(geom->type));
                return NULL;
        }
 
        /* In case this is a truly empty, make some initial space  */
        if (!col->geoms)
        {
                col->maxgeoms = 2;
                col->ngeoms = 0;
                col->geoms = lwalloc(col->maxgeoms * sizeof(LWGEOM*));
        }
 
        /* Allocate more space if we need it */
        lwcollection_reserve(col, col->ngeoms + 1);
 
#ifndef NDEBUG
        /* See http://trac.osgeo.org/postgis/ticket/2933 */
        /* Make sure we don't already have a reference to this geom */
        {
                for (uint32_t i = 0; i < col->ngeoms; i++)
                {
                        if (col->geoms[i] == geom)
                        {
                                lwerror("%s [%d] found duplicate geometry in collection %p == %p", __FILE__, __LINE__, col->geoms[i], geom);
                                return col;
                        }
                }
        }
#endif
 
        col->geoms[col->ngeoms] = (LWGEOM*)geom;
        col->ngeoms++;
        return col;
}
 
LWCOLLECTION *
lwcollection_concat_in_place(LWCOLLECTION *col1, const LWCOLLECTION *col2)
{
        uint32_t i;
        if (!col1 || !col2) return NULL;
        for (i = 0; i < col2->ngeoms; i++)
                col1 = lwcollection_add_lwgeom(col1, col2->geoms[i]);
        return col1;
}
 
LWCOLLECTION*
lwcollection_segmentize2d(const LWCOLLECTION* col, double dist)
{
        uint32_t i, j;
        LWGEOM** newgeoms;
 
        if (!col->ngeoms) return lwcollection_clone(col);
 
        newgeoms = lwalloc(sizeof(LWGEOM*) * col->ngeoms);
        for (i = 0; i < col->ngeoms; i++)
        {
                newgeoms[i] = lwgeom_segmentize2d(col->geoms[i], dist);
                if (!newgeoms[i])
                {
                        for (j = 0; j < i; j++)
                                lwgeom_free(newgeoms[j]);
                        lwfree(newgeoms);
                        return NULL;
                }
        }
 
        return lwcollection_construct(
            col->type, col->srid, NULL, col->ngeoms, newgeoms);
}
 
char
lwcollection_same(const LWCOLLECTION *c1, const LWCOLLECTION *c2)
{
        uint32_t i;
 
        LWDEBUG(2, "lwcollection_same called");
 
        if ( c1->type != c2->type ) return LW_FALSE;
        if ( c1->ngeoms != c2->ngeoms ) return LW_FALSE;
 
        for ( i = 0; i < c1->ngeoms; i++ )
        {
                if ( ! lwgeom_same(c1->geoms[i], c2->geoms[i]) )
                        return LW_FALSE;
        }
 
        /* Former method allowed out-of-order equality between collections
 
                hit = lwalloc(sizeof(uint32_t)*c1->ngeoms);
                memset(hit, 0, sizeof(uint32_t)*c1->ngeoms);
 
                for (i=0; i<c1->ngeoms; i++)
                {
                        char found=0;
                        for (j=0; j<c2->ngeoms; j++)
                        {
                                if ( hit[j] ) continue;
                                if ( lwgeom_same(c1->geoms[i], c2->geoms[j]) )
                                {
                                        hit[j] = 1;
                                        found=1;
                                        break;
                                }
                        }
                        if ( ! found ) return LW_FALSE;
                }
        */
 
        return LW_TRUE;
}
 
int lwcollection_ngeoms(const LWCOLLECTION *col)
{
        uint32_t i;
        int ngeoms = 0;
 
        if ( ! col )
        {
                lwerror("Null input geometry.");
                return 0;
        }
 
        for ( i = 0; i < col->ngeoms; i++ )
        {
                if ( col->geoms[i])
                {
                        switch (col->geoms[i]->type)
                        {
                        case POINTTYPE:
                        case LINETYPE:
                        case CIRCSTRINGTYPE:
                        case POLYGONTYPE:
                                ngeoms += 1;
                                break;
                        case MULTIPOINTTYPE:
                        case MULTILINETYPE:
                        case MULTICURVETYPE:
                        case MULTIPOLYGONTYPE:
                                ngeoms += col->ngeoms;
                                break;
                        case COLLECTIONTYPE:
                                ngeoms += lwcollection_ngeoms((LWCOLLECTION*)col->geoms[i]);
                                break;
                        }
                }
        }
        return ngeoms;
}
 
void lwcollection_free(LWCOLLECTION *col)
{
        uint32_t i;
        if ( ! col ) return;
 
        if ( col->bbox )
        {
                lwfree(col->bbox);
        }
        for ( i = 0; i < col->ngeoms; i++ )
        {
                LWDEBUGF(4,"freeing geom[%d]", i);
                if ( col->geoms && col->geoms[i] )
                        lwgeom_free(col->geoms[i]);
        }
        if ( col->geoms )
        {
                lwfree(col->geoms);
        }
        lwfree(col);
}
 
static uint32_t
lwcollection_largest_dimension(const LWCOLLECTION *col)
{
        int largest_type = 0;
        size_t i;
        for (i = 0; i < col->ngeoms; i++)
        {
                LWGEOM *g = col->geoms[i];
                int gtype = lwgeom_get_type(g);
                if (lwgeom_is_collection(g))
                {
                        gtype = lwcollection_largest_dimension((LWCOLLECTION*)g);
                }
 
                if (gtype == POINTTYPE || gtype == LINETYPE || gtype == POLYGONTYPE)
                {
                        if (gtype > largest_type)
                                largest_type = gtype;
                }
        }
        return largest_type;
}
 
 
static int
lwcollection_extract_recursive(const LWCOLLECTION* col, uint32_t type, LWCOLLECTION *col_out)
{
        size_t i;
        size_t geoms_added = 0;
 
        for (i = 0; i < col->ngeoms; i++)
        {
                LWGEOM *g = col->geoms[i];
                if (lwgeom_is_collection(g))
                {
                        LWCOLLECTION *col_part = lwgeom_as_lwcollection(g);
                        geoms_added += lwcollection_extract_recursive(col_part, type, col_out);
                }
 
                if (lwgeom_get_type(g) == type && !lwgeom_is_empty(g))
                {
                        lwcollection_add_lwgeom(col_out, lwgeom_clone(col->geoms[i]));
                        geoms_added++;
                }
        }
        return geoms_added;
}
 
LWCOLLECTION*
lwcollection_extract(const LWCOLLECTION* col, uint32_t type)
{
        LWCOLLECTION* outcol;
 
        if (!col) return NULL;
 
        /* Self-discover output type when it is not specified */
        if (!type)
                type = lwcollection_largest_dimension(col);
 
        /*
        * If self-discovery failed, there were no primitive points
        * lines or polygons in the collection, so send back an
        * empty collection.
        */
        if (!type)
        {
                return lwcollection_construct_empty(COLLECTIONTYPE,
                   col->srid,
                   FLAGS_GET_Z(col->flags),
                   FLAGS_GET_M(col->flags));
        }
 
        if (!(type == POINTTYPE || type == LINETYPE || type == POLYGONTYPE))
        {
                lwerror(
                    "Only POLYGON, LINESTRING and POINT are supported by "
                    "lwcollection_extract. %s requested.",
                    lwtype_name(type));
                return NULL;
        }
 
        outcol = lwcollection_construct_empty(lwtype_multitype(type),
                   col->srid,
                   FLAGS_GET_Z(col->flags),
                   FLAGS_GET_M(col->flags));
 
        lwcollection_extract_recursive(col, type, outcol);
        lwgeom_add_bbox(lwcollection_as_lwgeom(outcol));
        return outcol;
}
 
 
LWCOLLECTION*
lwcollection_force_dims(const LWCOLLECTION *col, int hasz, int hasm, double zval, double mval)
{
        LWCOLLECTION *colout;
 
        /* Return 2D empty */
        if( lwcollection_is_empty(col) )
        {
                colout = lwcollection_construct_empty(col->type, col->srid, hasz, hasm);
        }
        else
        {
                uint32_t i;
                LWGEOM **geoms = NULL;
                geoms = lwalloc(sizeof(LWGEOM*) * col->ngeoms);
                for( i = 0; i < col->ngeoms; i++ )
                {
                        geoms[i] = lwgeom_force_dims(col->geoms[i], hasz, hasm, zval, mval);
                }
                colout = lwcollection_construct(col->type, col->srid, NULL, col->ngeoms, geoms);
        }
        return colout;
}
 
 
uint32_t lwcollection_count_vertices(const LWCOLLECTION *col)
{
        uint32_t i = 0;
        uint32_t v = 0; /* vertices */
        assert(col);
        for ( i = 0; i < col->ngeoms; i++ )
        {
                v += lwgeom_count_vertices(col->geoms[i]);
        }
        return v;
}
 
 
int lwcollection_allows_subtype(int collectiontype, int subtype)
{
        if ( collectiontype == COLLECTIONTYPE )
                return LW_TRUE;
        if ( collectiontype == MULTIPOINTTYPE &&
                subtype == POINTTYPE )
                return LW_TRUE;
        if ( collectiontype == MULTILINETYPE &&
                subtype == LINETYPE )
                return LW_TRUE;
        if ( collectiontype == MULTIPOLYGONTYPE &&
                subtype == POLYGONTYPE )
                return LW_TRUE;
        if ( collectiontype == COMPOUNDTYPE &&
                (subtype == LINETYPE || subtype == CIRCSTRINGTYPE) )
                return LW_TRUE;
        if ( collectiontype == CURVEPOLYTYPE &&
                (subtype == CIRCSTRINGTYPE || subtype == LINETYPE || subtype == COMPOUNDTYPE) )
                return LW_TRUE;
        if ( collectiontype == MULTICURVETYPE &&
                (subtype == CIRCSTRINGTYPE || subtype == LINETYPE || subtype == COMPOUNDTYPE) )
                return LW_TRUE;
        if ( collectiontype == MULTISURFACETYPE &&
                (subtype == POLYGONTYPE || subtype == CURVEPOLYTYPE) )
                return LW_TRUE;
        if ( collectiontype == POLYHEDRALSURFACETYPE &&
                subtype == POLYGONTYPE )
                return LW_TRUE;
        if ( collectiontype == TINTYPE &&
                subtype == TRIANGLETYPE )
                return LW_TRUE;
 
        /* Must be a bad combination! */
        return LW_FALSE;
}
 
int
lwcollection_startpoint(const LWCOLLECTION* col, POINT4D* pt)
{
        if ( col->ngeoms < 1 )
                return LW_FAILURE;
 
        return lwgeom_startpoint(col->geoms[0], pt);
}