ptarray_simplify_in_place()

void ptarray_simplify_in_place	(	POINTARRAY *	pa,
		double	epsilon,
		uint32_t	minpts
	)

Parameters

minpts

minimum number of points to retain, if possible.

Definition at line 1576 of file ptarray.c.

{
        static size_t stack_size = 256;
        int *stack, *outlist; /* recursion stack */
        int stack_static[stack_size];
        int outlist_static[stack_size];
        int sp = -1; /* recursion stack pointer */
        int p1, split;
        uint32_t outn = 0;
        int pai = 0;
        uint32_t i;
        double dist;
        double eps_sqr = epsilon * epsilon;
 
        /* Do not try to simplify really short things */
        if (pa->npoints < 3) return;
 
        /* Only heap allocate book-keeping arrays if necessary */
        if (pa->npoints > stack_size)
        {
                stack = lwalloc(sizeof(int) * pa->npoints);
                outlist = lwalloc(sizeof(int) * pa->npoints);
        }
        else
        {
                stack = stack_static;
                outlist = outlist_static;
        }
 
        p1 = 0;
        stack[++sp] = pa->npoints-1;
 
        /* Add first point to output list */
        outlist[outn++] = 0;
        do
        {
                ptarray_dp_findsplit_in_place(pa, p1, stack[sp], &split, &dist);
 
                if ((dist > eps_sqr) || ((outn + sp+1 < minpts) && (dist >= 0)))
                {
                        stack[++sp] = split;
                }
                else
                {
                        outlist[outn++] = stack[sp];
                        p1 = stack[sp--];
                }
        }
        while (!(sp<0));
 
        /* Put list of retained points into order */
        qsort(outlist, outn, sizeof(int), int_cmp);
        /* Copy retained points to front of array */
        for (i = 0; i < outn; i++)
        {
                int j = outlist[i];
                /* Indexes the same, means no copy required */
                if (j == pai)
                {
                        pai++;
                        continue;
                }
                /* Indexes different, copy value down */
                ptarray_copy_point(pa, j, pai++);
        }
 
        /* Adjust point count on array */
        pa->npoints = outn;
 
        /* Only free if arrays are on heap */
        if (stack != stack_static)
                lwfree(stack);
        if (outlist != outlist_static)
                lwfree(outlist);
 
        return;
}

References int_cmp(), lwalloc(), lwfree(), POINTARRAY::npoints, ptarray_copy_point(), and ptarray_dp_findsplit_in_place().

Referenced by lwgeom_simplify_in_place().

Here is the call graph for this function:

Here is the caller graph for this function: