/**
* Create a new point. Null point array implies empty. Null dimensionality
* implies no specified dimensionality in the WKT.
*/
LWGEOM* wkt_parser_point_new(POINTARRAY *pa, char *dimensionality)
{
uint8_t flags = wkt_dimensionality(dimensionality);
LWDEBUG(4,"entered");
/* No pointarray means it is empty */
if( ! pa )
return lwpoint_as_lwgeom(lwpoint_construct_empty(SRID_UNKNOWN, FLAGS_GET_Z(flags), FLAGS_GET_M(flags)));
/* If the number of dimensions is not consistent, we have a problem. */
if( wkt_pointarray_dimensionality(pa, flags) == LW_FALSE )
{
ptarray_free(pa);
SET_PARSER_ERROR(PARSER_ERROR_MIXDIMS);
return NULL;
}
/* Only one point allowed in our point array! */
if( pa->npoints != 1 )
{
ptarray_free(pa);
SET_PARSER_ERROR(PARSER_ERROR_LESSPOINTS);
return NULL;
}
return lwpoint_as_lwgeom(lwpoint_construct(SRID_UNKNOWN, NULL, pa));
}
/**
* Create a new linestring. Null point array implies empty. Null dimensionality
* implies no specified dimensionality in the WKT. Check for numpoints >= 2 if
* requested.
*/
LWGEOM* wkt_parser_linestring_new(POINTARRAY *pa, char *dimensionality)
{
uint8_t flags = wkt_dimensionality(dimensionality);
LWDEBUG(4,"entered");
/* No pointarray means it is empty */
if( ! pa )
return lwline_as_lwgeom(lwline_construct_empty(SRID_UNKNOWN, FLAGS_GET_Z(flags), FLAGS_GET_M(flags)));
/* If the number of dimensions is not consistent, we have a problem. */
if( wkt_pointarray_dimensionality(pa, flags) == LW_FALSE )
{
ptarray_free(pa);
SET_PARSER_ERROR(PARSER_ERROR_MIXDIMS);
return NULL;
}
/* Apply check for not enough points, if requested. */
if( (global_parser_result.parser_check_flags & LW_PARSER_CHECK_MINPOINTS) && (pa->npoints < 2) )
{
ptarray_free(pa);
SET_PARSER_ERROR(PARSER_ERROR_MOREPOINTS);
return NULL;
}
return lwline_as_lwgeom(lwline_construct(SRID_UNKNOWN, NULL, pa));
}
POINTARRAY* wkt_parser_ptarray_add_coord(POINTARRAY *pa, POINT p)
{
POINT4D pt;
LWDEBUG(4,"entered");
/* Error on trouble */
if( ! pa )
{
SET_PARSER_ERROR(PARSER_ERROR_OTHER);
return NULL;
}
/* Check that the coordinate has the same dimesionality as the array */
if( FLAGS_NDIMS(p.flags) != FLAGS_NDIMS(pa->flags) )
{
ptarray_free(pa);
SET_PARSER_ERROR(PARSER_ERROR_MIXDIMS);
return NULL;
}
/* While parsing the point arrays, XYM and XMZ points are both treated as XYZ */
pt.x = p.x;
pt.y = p.y;
if( FLAGS_GET_Z(pa->flags) )
pt.z = p.z;
if( FLAGS_GET_M(pa->flags) )
pt.m = p.m;
/* If the destination is XYM, we'll write the third coordinate to m */
if( FLAGS_GET_M(pa->flags) && ! FLAGS_GET_Z(pa->flags) )
pt.m = p.z;
ptarray_append_point(pa, &pt, LW_TRUE); /* Allow duplicate points in array */
return pa;
}
LWGEOM* wkt_parser_compound_add_geom(LWGEOM *col, LWGEOM *geom)
{
LWDEBUG(4,"entered");
/* Toss error on null geometry input */
if( ! (geom && col) )
{
SET_PARSER_ERROR(PARSER_ERROR_OTHER);
return NULL;
}
/* All the elements must agree on dimensionality */
if( FLAGS_NDIMS(col->flags) != FLAGS_NDIMS(geom->flags) )
{
lwgeom_free(col);
lwgeom_free(geom);
SET_PARSER_ERROR(PARSER_ERROR_MIXDIMS);
return NULL;
}
if( LW_FAILURE == lwcompound_add_lwgeom((LWCOMPOUND*)col, geom) )
{
lwgeom_free(col);
lwgeom_free(geom);
SET_PARSER_ERROR(PARSER_ERROR_INCONTINUOUS);
return NULL;
}
return col;
}
LWGEOM* wkt_parser_curvepolygon_finalize(LWGEOM *poly, char *dimensionality)
{
uint8_t flags = wkt_dimensionality(dimensionality);
int flagdims = FLAGS_NDIMS(flags);
LWDEBUG(4,"entered");
/* Null input implies empty return */
if( ! poly )
return lwcurvepoly_as_lwgeom(lwcurvepoly_construct_empty(SRID_UNKNOWN, FLAGS_GET_Z(flags), FLAGS_GET_M(flags)));
if ( flagdims > 2 )
{
/* If the number of dimensions are not consistent, we have a problem. */
if( flagdims != FLAGS_NDIMS(poly->flags) )
{
lwgeom_free(poly);
SET_PARSER_ERROR(PARSER_ERROR_MIXDIMS);
return NULL;
}
/* Harmonize the flags in the sub-components with the wkt flags */
if( LW_FAILURE == wkt_parser_set_dims(poly, flags) )
{
lwgeom_free(poly);
SET_PARSER_ERROR(PARSER_ERROR_OTHER);
return NULL;
}
}
return poly;
}
LWGEOM* wkt_parser_triangle_new(POINTARRAY *pa, char *dimensionality)
{
uint8_t flags = wkt_dimensionality(dimensionality);
LWDEBUG(4,"entered");
/* No pointarray means it is empty */
if( ! pa )
return lwtriangle_as_lwgeom(lwtriangle_construct_empty(SRID_UNKNOWN, FLAGS_GET_Z(flags), FLAGS_GET_M(flags)));
/* If the number of dimensions is not consistent, we have a problem. */
if( wkt_pointarray_dimensionality(pa, flags) == LW_FALSE )
{
ptarray_free(pa);
SET_PARSER_ERROR(PARSER_ERROR_MIXDIMS);
return NULL;
}
/* Triangles need four points. */
if( (pa->npoints != 4) )
{
ptarray_free(pa);
SET_PARSER_ERROR(PARSER_ERROR_TRIANGLEPOINTS);
return NULL;
}
/* Triangles need closure. */
if( ! ptarray_isclosed(pa) )
{
ptarray_free(pa);
SET_PARSER_ERROR(PARSER_ERROR_UNCLOSED);
return NULL;
}
return lwtriangle_as_lwgeom(lwtriangle_construct(SRID_UNKNOWN, NULL, pa));
}
LWGEOM* wkt_parser_polygon_add_ring(LWGEOM *poly, POINTARRAY *pa, char dimcheck)
{
LWDEBUG(4,"entered");
/* Bad inputs are a problem */
if( ! (pa && poly) )
{
SET_PARSER_ERROR(PARSER_ERROR_OTHER);
return NULL;
}
/* Rings must agree on dimensionality */
if( FLAGS_NDIMS(poly->flags) != FLAGS_NDIMS(pa->flags) )
{
ptarray_free(pa);
lwgeom_free(poly);
SET_PARSER_ERROR(PARSER_ERROR_MIXDIMS);
return NULL;
}
/* Apply check for minimum number of points, if requested. */
if( (global_parser_result.parser_check_flags & LW_PARSER_CHECK_MINPOINTS) && (pa->npoints < 4) )
{
ptarray_free(pa);
lwgeom_free(poly);
SET_PARSER_ERROR(PARSER_ERROR_MOREPOINTS);
return NULL;
}
/* Apply check for not closed rings, if requested. */
if( (global_parser_result.parser_check_flags & LW_PARSER_CHECK_CLOSURE) &&
! (dimcheck == 'Z' ? ptarray_isclosedz(pa) : ptarray_isclosed2d(pa)) )
{
ptarray_free(pa);
lwgeom_free(poly);
SET_PARSER_ERROR(PARSER_ERROR_UNCLOSED);
return NULL;
}
/* If something goes wrong adding a ring, error out. */
if ( LW_FAILURE == lwpoly_add_ring(lwgeom_as_lwpoly(poly), pa) )
{
ptarray_free(pa);
lwgeom_free(poly);
SET_PARSER_ERROR(PARSER_ERROR_OTHER);
return NULL;
}
return poly;
}
LWGEOM* wkt_parser_collection_finalize(int lwtype, LWGEOM *col, char *dimensionality)
{
uint8_t flags = wkt_dimensionality(dimensionality);
int flagdims = FLAGS_NDIMS(flags);
/* No geometry means it is empty */
if( ! col )
{
return lwcollection_as_lwgeom(lwcollection_construct_empty(lwtype, SRID_UNKNOWN, FLAGS_GET_Z(flags), FLAGS_GET_M(flags)));
}
/* There are 'Z' or 'M' tokens in the signature */
if ( flagdims > 2 )
{
/* If the number of dimensions are not consistent, we have a problem. */
if( flagdims != FLAGS_NDIMS(col->flags) )
{
lwgeom_free(col);
SET_PARSER_ERROR(PARSER_ERROR_MIXDIMS);
return NULL;
}
/* For GEOMETRYCOLLECTION, the exact type of the dimensions must match too */
if( lwtype == COLLECTIONTYPE &&
( (FLAGS_GET_Z(flags) != FLAGS_GET_Z(col->flags)) ||
(FLAGS_GET_M(flags) != FLAGS_GET_M(col->flags)) ) )
{
lwgeom_free(col);
SET_PARSER_ERROR(PARSER_ERROR_MIXDIMS);
return NULL;
}
/* Harmonize the collection dimensionality */
if( LW_FAILURE == wkt_parser_set_dims(col, flags) )
{
lwgeom_free(col);
SET_PARSER_ERROR(PARSER_ERROR_OTHER);
return NULL;
}
}
/* Set the collection type */
col->type=lwtype;
return col;
}
/**
* Start a point array from the first coordinate.
*/
POINTARRAY* wkt_parser_ptarray_new(POINT p)
{
int ndims = FLAGS_NDIMS(p.flags);
LWDEBUG(4,"entered");
POINTARRAY *pa = ptarray_construct_empty((ndims>2), (ndims>3), 4);
if ( ! pa )
{
SET_PARSER_ERROR(PARSER_ERROR_OTHER);
return NULL;
}
return wkt_parser_ptarray_add_coord(pa, p);
}
LWGEOM* wkt_parser_collection_add_geom(LWGEOM *col, LWGEOM *geom)
{
LWDEBUG(4,"entered");
/* Toss error on null geometry input */
if( ! (geom && col) )
{
SET_PARSER_ERROR(PARSER_ERROR_OTHER);
return NULL;
}
/* All the elements must agree on dimensionality */
if( FLAGS_NDIMS(col->flags) != FLAGS_NDIMS(geom->flags) )
{
lwgeom_free(col);
lwgeom_free(geom);
SET_PARSER_ERROR(PARSER_ERROR_MIXDIMS);
return NULL;
}
return lwcollection_as_lwgeom(lwcollection_add_lwgeom(lwgeom_as_lwcollection(col), geom));
}
LWGEOM* wkt_parser_polygon_new(POINTARRAY *pa, char dimcheck)
{
LWPOLY *poly = NULL;
LWDEBUG(4,"entered");
/* No pointarray is a problem */
if( ! pa )
{
SET_PARSER_ERROR(PARSER_ERROR_OTHER);
return NULL;
}
poly = lwpoly_construct_empty(SRID_UNKNOWN, FLAGS_GET_Z(pa->flags), FLAGS_GET_M(pa->flags));
/* Error out if we can't build this polygon. */
if( ! poly )
{
SET_PARSER_ERROR(PARSER_ERROR_OTHER);
return NULL;
}
wkt_parser_polygon_add_ring(lwpoly_as_lwgeom(poly), pa, dimcheck);
return lwpoly_as_lwgeom(poly);
}
LWGEOM* wkt_parser_curvepolygon_new(LWGEOM *ring)
{
LWGEOM *poly;
LWDEBUG(4,"entered");
/* Toss error on null geometry input */
if( ! ring )
{
SET_PARSER_ERROR(PARSER_ERROR_OTHER);
return NULL;
}
/* Construct poly and add the ring. */
poly = lwcurvepoly_as_lwgeom(lwcurvepoly_construct_empty(SRID_UNKNOWN, FLAGS_GET_Z(ring->flags), FLAGS_GET_M(ring->flags)));
/* Return the result. */
return wkt_parser_curvepolygon_add_ring(poly,ring);
}
LWGEOM* wkt_parser_collection_new(LWGEOM *geom)
{
LWCOLLECTION *col;
LWGEOM **geoms;
static int ngeoms = 1;
LWDEBUG(4,"entered");
/* Toss error on null geometry input */
if( ! geom )
{
SET_PARSER_ERROR(PARSER_ERROR_OTHER);
return NULL;
}
/* Create our geometry array */
geoms = lwalloc(sizeof(LWGEOM*) * ngeoms);
geoms[0] = geom;
/* Make a new collection */
col = lwcollection_construct(COLLECTIONTYPE, SRID_UNKNOWN, NULL, ngeoms, geoms);
/* Return the result. */
return lwcollection_as_lwgeom(col);
}
LWGEOM* wkt_parser_curvepolygon_add_ring(LWGEOM *poly, LWGEOM *ring)
{
LWDEBUG(4,"entered");
/* Toss error on null input */
if( ! (ring && poly) )
{
SET_PARSER_ERROR(PARSER_ERROR_OTHER);
LWDEBUG(4,"inputs are null");
return NULL;
}
/* All the elements must agree on dimensionality */
if( FLAGS_NDIMS(poly->flags) != FLAGS_NDIMS(ring->flags) )
{
LWDEBUG(4,"dimensionality does not match");
lwgeom_free(ring);
lwgeom_free(poly);
SET_PARSER_ERROR(PARSER_ERROR_MIXDIMS);
return NULL;
}
/* Apply check for minimum number of points, if requested. */
if( (global_parser_result.parser_check_flags & LW_PARSER_CHECK_MINPOINTS) &&
(lwgeom_count_vertices(ring) < 4) )
{
LWDEBUG(4,"number of points is incorrect");
lwgeom_free(ring);
lwgeom_free(poly);
SET_PARSER_ERROR(PARSER_ERROR_MOREPOINTS);
return NULL;
}
/* Apply check for not closed rings, if requested. */
if( (global_parser_result.parser_check_flags & LW_PARSER_CHECK_CLOSURE) )
{
int is_closed = 1;
LWDEBUG(4,"checking ring closure");
switch ( ring->type )
{
case LINETYPE:
is_closed = lwline_is_closed(lwgeom_as_lwline(ring));
break;
case CIRCSTRINGTYPE:
is_closed = lwcircstring_is_closed(lwgeom_as_lwcircstring(ring));
break;
case COMPOUNDTYPE:
is_closed = lwcompound_is_closed(lwgeom_as_lwcompound(ring));
break;
}
if ( ! is_closed )
{
LWDEBUG(4,"ring is not closed");
lwgeom_free(ring);
lwgeom_free(poly);
SET_PARSER_ERROR(PARSER_ERROR_UNCLOSED);
return NULL;
}
}
if( LW_FAILURE == lwcurvepoly_add_ring(lwgeom_as_lwcurvepoly(poly), ring) )
{
LWDEBUG(4,"failed to add ring");
lwgeom_free(ring);
lwgeom_free(poly);
SET_PARSER_ERROR(PARSER_ERROR_OTHER);
return NULL;
}
return poly;
}
