lwgeom_remove_repeated_points_in_place()

int lwgeom_remove_repeated_points_in_place	(	LWGEOM *	in,
		double	tolerance
	)

Definition at line 1604 of file lwgeom.c.

{
        int geometry_modified = LW_FALSE;
        switch (geom->type)
        {
        /* No-op! Cannot remove 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 input, discard the collapsed line */
                if (pa->npoints < 2)
                {
                        pa->npoints = 0;
                        geometry_modified = LW_TRUE;
                }
                break;
        }
        case POLYGONTYPE: {
                uint32_t j = 0;
                LWPOLY *g = (LWPOLY *)(geom);
                for (uint32_t i = 0; i < g->nrings; i++)
                {
                        POINTARRAY *pa = g->rings[i];
                        uint32_t npoints = pa->npoints;
                        ptarray_remove_repeated_points_in_place(pa, tolerance, 4);
                        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: {
                double tolsq = tolerance * tolerance;
                LWMPOINT *mpt = (LWMPOINT *)geom;
 
                for (uint8_t dim = 0; dim < 2; dim++)
                {
                        /* sort by y, then by x - this way the result is sorted by x */
                        qsort(mpt->geoms, mpt->ngeoms, sizeof(LWPOINT *), dim ? cmp_point_x : cmp_point_y);
                        for (uint32_t i = 0; i < mpt->ngeoms; i++)
                        {
                                if (!mpt->geoms[i])
                                        continue;
 
                                const POINT2D *pti = getPoint2d_cp(mpt->geoms[i]->point, 0);
                                if (!pti) continue;
 
                                /* check upcoming points if they're within tolerance of current one */
                                for (uint32_t j = i + 1; j < mpt->ngeoms; j++)
                                {
                                        if (!mpt->geoms[j])
                                                continue;
 
                                        const POINT2D *ptj = getPoint2d_cp(mpt->geoms[j]->point, 0);
                                        if (!ptj) continue;
 
                                        /* check that the point is in the strip of tolerance around the point */
                                        if ((dim ? ptj->x - pti->x : ptj->y - pti->y) > tolerance)
                                                break;
 
                                        /* remove any upcoming point that is within tolerance circle */
                                        if (distance2d_sqr_pt_pt(pti, ptj) <= tolsq)
                                        {
                                                lwpoint_free(mpt->geoms[j]);
                                                mpt->geoms[j] = NULL;
                                                geometry_modified = LW_TRUE;
                                        }
                                }
                        }
 
                        /* null out empties */
                        for (uint32_t j = 0; j < mpt->ngeoms; j++)
                        {
                                if (mpt->geoms[j] && lwpoint_is_empty(mpt->geoms[j]))
                                {
                                        lwpoint_free(mpt->geoms[j]);
                                        mpt->geoms[j] = NULL;
                                        geometry_modified = LW_TRUE;
                                }
                        }
 
                        /* compactify array of points */
                        uint32_t i = 0;
                        for (uint32_t j = 0; j < mpt->ngeoms; j++)
                                if (mpt->geoms[j])
                                        mpt->geoms[i++] = mpt->geoms[j];
                        mpt->ngeoms = i;
                }
 
                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, cmp_point_x(), cmp_point_y(), COLLECTIONTYPE, COMPOUNDTYPE, CURVEPOLYTYPE, distance2d_sqr_pt_pt(), LWMPOINT::geoms, LWCOLLECTION::geoms, getPoint2d_cp(), LINETYPE, LW_FALSE, LW_TRUE, lwerror(), lwgeom_drop_bbox(), lwgeom_free(), lwgeom_is_empty(), lwgeom_remove_repeated_points_in_place(), lwpoint_free(), lwpoint_is_empty(), lwtype_name(), MULTICURVETYPE, MULTILINETYPE, MULTIPOINTTYPE, MULTIPOLYGONTYPE, MULTISURFACETYPE, LWMPOINT::ngeoms, LWCOLLECTION::ngeoms, POINTARRAY::npoints, LWPOLY::nrings, LWPOINT::point, LWLINE::points, POINTTYPE, POLYGONTYPE, ptarray_free(), ptarray_remove_repeated_points_in_place(), LWPOLY::rings, TINTYPE, TRIANGLETYPE, LWGEOM::type, POINT2D::x, and POINT2D::y.

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: