pta_unstroke()

LWGEOM * pta_unstroke	(	const POINTARRAY *	points,
		int	type,
		int	srid
	)

Definition at line 883 of file lwstroke.c.

References COMPOUNDTYPE, geom_from_pa(), LWCOLLECTION::geoms, getPoint4d_p(), lw_arc_angle(), lw_arc_center(), LW_FALSE, lw_segment_side(), LW_TRUE, lwalloc(), lwcollection_add_lwgeom(), lwcollection_as_lwgeom(), lwcollection_construct_empty(), lwcollection_free(), LWDEBUG, LWDEBUGF, lwerror(), lwfree(), LWCOLLECTION::ngeoms, POINTARRAY::npoints, pt_continues_arc(), ptarray_has_m(), ptarray_has_z(), POINT2D::x, POINT4D::x, POINT2D::y, and POINT4D::y.

Referenced by lwline_unstroke(), and lwpolygon_unstroke().

{
        int i = 0, j, k;
        POINT4D a1, a2, a3, b;
        POINT4D first, center;
        char *edges_in_arcs;
        int found_arc = LW_FALSE;
        int current_arc = 1;
        int num_edges;
        int edge_type; /* non-zero if edge is part of an arc */
        int start, end;
        LWCOLLECTION *outcol;
        /* Minimum number of edges, per quadrant, required to define an arc */
        const unsigned int min_quad_edges = 2;

        /* Die on null input */
        if ( ! points )
                lwerror("pta_unstroke called with null pointarray");

        /* Null on empty input? */
        if ( points->npoints == 0 )
                return NULL;

        /* We can't desegmentize anything shorter than four points */
        if ( points->npoints < 4 )
        {
                /* Return a linestring here*/
                lwerror("pta_unstroke needs implementation for npoints < 4");
        }

        /* Allocate our result array of vertices that are part of arcs */
        num_edges = points->npoints - 1;
        edges_in_arcs = lwalloc(num_edges + 1);
        memset(edges_in_arcs, 0, num_edges + 1);

        /* We make a candidate arc of the first two edges, */
        /* And then see if the next edge follows it */
        while( i < num_edges-2 )
        {
                unsigned int arc_edges;
                double num_quadrants;
                double angle;

                found_arc = LW_FALSE;
                /* Make candidate arc */
                getPoint4d_p(points, i  , &a1);
                getPoint4d_p(points, i+1, &a2);
                getPoint4d_p(points, i+2, &a3);
                memcpy(&first, &a1, sizeof(POINT4D));

                for( j = i+3; j < num_edges+1; j++ )
                {
                        LWDEBUGF(4, "i=%d, j=%d", i, j);
                        getPoint4d_p(points, j, &b);
                        /* Does this point fall on our candidate arc? */
                        if ( pt_continues_arc(&a1, &a2, &a3, &b) )
                        {
                                /* Yes. Mark this edge and the two preceding it as arc components */
                                LWDEBUGF(4, "pt_continues_arc #%d", current_arc);
                                found_arc = LW_TRUE;
                                for ( k = j-1; k > j-4; k-- )
                                        edges_in_arcs[k] = current_arc;
                        }
                        else
                        {
                                /* No. So we're done with this candidate arc */
                                LWDEBUG(4, "pt_continues_arc = false");
                                current_arc++;
                                break;
                        }

                        memcpy(&a1, &a2, sizeof(POINT4D));
                        memcpy(&a2, &a3, sizeof(POINT4D));
                        memcpy(&a3,  &b, sizeof(POINT4D));
                }
                /* Jump past all the edges that were added to the arc */
                if ( found_arc )
                {
                        /* Check if an arc was composed by enough edges to be
                         * really considered an arc
                         * See http://trac.osgeo.org/postgis/ticket/2420
                         */
                        arc_edges = j - 1 - i;
                        LWDEBUGF(4, "arc defined by %d edges found", arc_edges);
                        if ( first.x == b.x && first.y == b.y ) {
                                LWDEBUG(4, "arc is a circle");
                                num_quadrants = 4;
                        }
                        else {
                                lw_arc_center((POINT2D*)&first, (POINT2D*)&b, (POINT2D*)&a1, (POINT2D*)&center);
                                angle = lw_arc_angle((POINT2D*)&first, (POINT2D*)&center, (POINT2D*)&b);
        int p2_side = lw_segment_side((POINT2D*)&first, (POINT2D*)&a1, (POINT2D*)&b);
        if ( p2_side >= 0 ) angle = -angle;

                                if ( angle < 0 ) angle = 2 * M_PI + angle;
                                num_quadrants = ( 4 * angle ) / ( 2 * M_PI );
                                LWDEBUGF(4, "arc angle (%g %g, %g %g, %g %g) is %g (side is %d), quandrants:%g", first.x, first.y, center.x, center.y, b.x, b.y, angle, p2_side, num_quadrants);
                        }
                        /* a1 is first point, b is last point */
                        if ( arc_edges < min_quad_edges * num_quadrants ) {
                                LWDEBUGF(4, "Not enough edges for a %g quadrants arc, %g needed", num_quadrants, min_quad_edges * num_quadrants);
                                for ( k = j-1; k >= i; k-- )
                                        edges_in_arcs[k] = 0;
                        }

                        i = j-1;
                }
                else
                {
                        /* Mark this edge as a linear edge */
                        edges_in_arcs[i] = 0;
                        i = i+1;
                }
        }

#if POSTGIS_DEBUG_LEVEL > 3
        {
                char *edgestr = lwalloc(num_edges+1);
                for ( i = 0; i < num_edges; i++ )
                {
                        if ( edges_in_arcs[i] )
                                edgestr[i] = 48 + edges_in_arcs[i];
                        else
                                edgestr[i] = '.';
                }
                edgestr[num_edges] = 0;
                LWDEBUGF(3, "edge pattern %s", edgestr);
                lwfree(edgestr);
        }
#endif

        start = 0;
        edge_type = edges_in_arcs[0];
        outcol = lwcollection_construct_empty(COMPOUNDTYPE, srid, ptarray_has_z(points), ptarray_has_m(points));
        for( i = 1; i < num_edges; i++ )
        {
                if( edge_type != edges_in_arcs[i] )
                {
                        end = i - 1;
                        lwcollection_add_lwgeom(outcol, geom_from_pa(points, srid, edge_type, start, end));
                        start = i;
                        edge_type = edges_in_arcs[i];
                }
        }
        lwfree(edges_in_arcs); /* not needed anymore */

        /* Roll out last item */
        end = num_edges - 1;
        lwcollection_add_lwgeom(outcol, geom_from_pa(points, srid, edge_type, start, end));

        /* Strip down to singleton if only one entry */
        if ( outcol->ngeoms == 1 )
        {
                LWGEOM *outgeom = outcol->geoms[0];
                outcol->ngeoms = 0; lwcollection_free(outcol);
                return outgeom;
        }
        return lwcollection_as_lwgeom(outcol);
}

Here is the call graph for this function:

Here is the caller graph for this function: