lwgeom_remove_repeated_points_in_place()

int lwgeom_remove_repeated_points_in_place	(	LWGEOM *	geom,
		double	tolerance
	)

Definition at line 1554 of file lwgeom.c.

{
        int geometry_modified = LW_FALSE;
        switch (geom->type)
        {
                /* No-op! Cannot remote points */
                case POINTTYPE:
                case TRIANGLETYPE:
                        return geometry_modified;
                case LINETYPE:
                {
                        LWLINE *g = (LWLINE*)(geom);
                        POINTARRAY *pa = g->points;
                        uint32_t npoints = pa->npoints;
                        ptarray_remove_repeated_points_in_place(pa, tolerance, 2);
                        geometry_modified = npoints != pa->npoints;
                        /* Invalid output */
                        if (pa->npoints == 1 && pa->maxpoints > 1)
                        {
                                /* Use first point as last point */
                                pa->npoints = 2;
                                ptarray_copy_point(pa, 0, 1);
                        }
                        break;
                }
                case POLYGONTYPE:
                {
                        uint32_t i, j = 0;
                        LWPOLY *g = (LWPOLY*)(geom);
                        for (i = 0; i < g->nrings; i++)
                        {
                                POINTARRAY *pa = g->rings[i];
                                int minpoints = 4;
                                uint32_t npoints = 0;
                                /* Skip zero'ed out rings */
                                if(!pa)
                                        continue;
                                npoints = pa->npoints;
                                ptarray_remove_repeated_points_in_place(pa, tolerance, minpoints);
                                geometry_modified |= npoints != pa->npoints;
                                /* Drop collapsed rings */
                                if(pa->npoints < 4)
                                {
                                        geometry_modified = LW_TRUE;
                                        ptarray_free(pa);
                                        continue;
                                }
                                g->rings[j++] = pa;
                        }
                        /* Update ring count */
                        g->nrings = j;
                        break;
                }
                case MULTIPOINTTYPE:
                {
                        static uint32_t out_stack_size = 32;
                        double tolsq = tolerance*tolerance;
                        uint32_t i, j, n = 0;
                        LWMPOINT *mpt = (LWMPOINT *)(geom);
                        LWPOINT **out;
                        LWPOINT *out_stack[out_stack_size];
                        int use_heap = (mpt->ngeoms > out_stack_size);
 
                        /* No-op on empty */
                        if (mpt->ngeoms < 2)
                                return geometry_modified;
 
                        /* We cannot write directly back to the multipoint */
                        /* geoms array because we're reading out of it still */
                        /* so we use a side array */
                        if (use_heap)
                                out = lwalloc(sizeof(LWMPOINT *) * mpt->ngeoms);
                        else
                                out = out_stack;
 
                        /* Inefficient O(n^2) implementation */
                        for (i = 0; i < mpt->ngeoms; i++)
                        {
                                int seen = 0;
                                LWPOINT *p1 = mpt->geoms[i];
                                const POINT2D *pt1 = getPoint2d_cp(p1->point, 0);
                                for (j = 0; j < n; j++)
                                {
                                        LWPOINT *p2 = out[j];
                                        const POINT2D *pt2 = getPoint2d_cp(p2->point, 0);
                                        if (distance2d_sqr_pt_pt(pt1, pt2) <= tolsq)
                                        {
                                                seen = 1;
                                                break;
                                        }
                                }
                                if (seen)
                                {
                                        lwpoint_free(p1);
                                        continue;
                                }
                                out[n++] = p1;
                        }
 
                        /* Copy remaining points back into the input */
                        /* array */
                        memcpy(mpt->geoms, out, sizeof(LWPOINT *) * n);
                        geometry_modified = mpt->ngeoms != n;
                        mpt->ngeoms = n;
                        if (use_heap) lwfree(out);
                        break;
                }
 
                case CIRCSTRINGTYPE:
                        /* Dunno how to handle these, will return untouched */
                        return geometry_modified;
 
                /* Can process most multi* types as generic collection */
                case MULTILINETYPE:
                case MULTIPOLYGONTYPE:
                case TINTYPE:
                case COLLECTIONTYPE:
                /* Curve types we mostly ignore, but allow the linear */
                /* portions to be processed by recursing into them */
                case MULTICURVETYPE:
                case CURVEPOLYTYPE:
                case MULTISURFACETYPE:
                case COMPOUNDTYPE:
                {
                        uint32_t i, j = 0;
                        LWCOLLECTION *col = (LWCOLLECTION*)(geom);
                        for (i = 0; i < col->ngeoms; i++)
                        {
                                LWGEOM *g = col->geoms[i];
                                if (!g) continue;
                                geometry_modified |= lwgeom_remove_repeated_points_in_place(g, tolerance);
                                /* Drop zero'ed out geometries */
                                if(lwgeom_is_empty(g))
                                {
                                        lwgeom_free(g);
                                        continue;
                                }
                                col->geoms[j++] = g;
                        }
                        /* Update geometry count */
                        col->ngeoms = j;
                        break;
                }
                default:
                {
                        lwerror("%s: unsupported geometry type: %s", __func__, lwtype_name(geom->type));
                        break;
                }
        }
 
        if (geometry_modified)
        {
                lwgeom_drop_bbox(geom);
        }
        return geometry_modified;
}

References CIRCSTRINGTYPE, COLLECTIONTYPE, COMPOUNDTYPE, CURVEPOLYTYPE, distance2d_sqr_pt_pt(), LWMPOINT::geoms, LWCOLLECTION::geoms, getPoint2d_cp(), LINETYPE, LW_FALSE, LW_TRUE, lwalloc(), lwerror(), lwfree(), lwgeom_drop_bbox(), lwgeom_free(), lwgeom_is_empty(), lwgeom_remove_repeated_points_in_place(), lwpoint_free(), lwtype_name(), POINTARRAY::maxpoints, MULTICURVETYPE, MULTILINETYPE, MULTIPOINTTYPE, MULTIPOLYGONTYPE, MULTISURFACETYPE, LWMPOINT::ngeoms, LWCOLLECTION::ngeoms, POINTARRAY::npoints, LWPOLY::nrings, LWPOINT::point, LWLINE::points, POINTTYPE, POLYGONTYPE, ptarray_copy_point(), ptarray_free(), ptarray_remove_repeated_points_in_place(), LWPOLY::rings, TINTYPE, TRIANGLETYPE, and LWGEOM::type.

Referenced by lwgeom_remove_repeated_points(), lwgeom_remove_repeated_points_in_place(), mvt_geom(), ST_RemoveRepeatedPoints(), and test_lwgeom_remove_repeated_points().

Here is the call graph for this function:

Here is the caller graph for this function: