ptarray_remove_repeated_points_in_place()

static void ptarray_remove_repeated_points_in_place ( POINTARRAY *  pa, double  tolerance, uint32_t  min_points  )

static

Definition at line 1468 of file ptarray.c.

References distance2d_sqr_pt_pt(), getPoint2d_cp(), POINTARRAY::npoints, ptarray_copy_point(), and ptarray_point_size().

Referenced by ptarray_remove_repeated_points_minpoints().

{
        uint32_t i;
        double tolsq = tolerance * tolerance;
        const POINT2D *last = NULL;
        const POINT2D *pt;
        uint32_t n_points = pa->npoints;
        uint32_t n_points_out = 1;
        size_t pt_size = ptarray_point_size(pa);

        double dsq = FLT_MAX;

        /* No-op on short inputs */
        if ( n_points <= min_points ) return;

        last = getPoint2d_cp(pa, 0);
        for (i = 1; i < n_points; i++)
        {
                int last_point = (i == n_points-1);

                /* Look straight into the abyss */
                pt = getPoint2d_cp(pa, i);

                /* Don't drop points if we are running short of points */
                if (n_points + n_points_out > min_points + i)
                {
                        if (tolerance > 0.0)
                        {
                                /* Only drop points that are within our tolerance */
                                dsq = distance2d_sqr_pt_pt(last, pt);
                                /* Allow any point but the last one to be dropped */
                                if (!last_point && dsq <= tolsq)
                                {
                                        continue;
                                }
                        }
                        else
                        {
                                /* At tolerance zero, only skip exact dupes */
                                if (memcmp((char*)pt, (char*)last, pt_size) == 0)
                                        continue;
                        }

                        /* Got to last point, and it's not very different from */
                        /* the point that preceded it. We want to keep the last */
                        /* point, not the second-to-last one, so we pull our write */
                        /* index back one value */
                        if (last_point && n_points_out > 1 && tolerance > 0.0 && dsq <= tolsq)
                        {
                                n_points_out--;
                        }
                }

                /* Compact all remaining values to front of array */
                ptarray_copy_point(pa, i, n_points_out++);
                last = pt;
        }
        /* Adjust array length */
        pa->npoints = n_points_out;
        return;
}

Here is the call graph for this function:

Here is the caller graph for this function: