lwarc_linearize()

static int lwarc_linearize ( POINTARRAY *  to, const POINT4D *  p1, const POINT4D *  p2, const POINT4D *  p3, double  tol, LW_LINEARIZE_TOLERANCE_TYPE  tolerance_type, int  flags  )

static

Segmentize an arc.

Does not add the final vertex

Parameters

to	POINTARRAY to append segmentized vertices to
p1	first point defining the arc
p2	second point defining the arc
p3	third point defining the arc
tol	tolerance, semantic driven by tolerance_type
tolerance_type	see LW_LINEARIZE_TOLERANCE_TYPE
flags	LW_LINEARIZE_FLAGS

Returns

number of points appended (0 if collinear), or -1 on error (lwerror would be called).

Definition at line 251 of file lwstroke.c.

{
        POINT2D center;
        POINT2D *t1 = (POINT2D*)p1;
        POINT2D *t2 = (POINT2D*)p2;
        POINT2D *t3 = (POINT2D*)p3;
        POINT4D pt;
        int p2_side = 0;
        int clockwise = LW_TRUE;
        double radius; /* Arc radius */
        double increment; /* Angle per segment */
        double angle_shift = 0;
        double a1, a2, a3;
        POINTARRAY *pa;
        int is_circle = LW_FALSE;
        int points_added = 0;
        int reverse = 0;
        int segments = 0;
 
        LWDEBUG(2, "lwarc_linearize called.");
 
        LWDEBUGF(2, " curve is CIRCULARSTRING(%.15g %.15f, %.15f %.15f, %.15f %15f)",
                t1->x, t1->y, t2->x, t2->y, t3->x, t3->y);
 
        p2_side = lw_segment_side(t1, t3, t2);
 
        LWDEBUGF(2, " p2 side is %d", p2_side);
 
        /* Force counterclockwise scan if SYMMETRIC operation is requested */
        if ( p2_side == -1 && flags & LW_LINEARIZE_FLAG_SYMMETRIC )
        {
                /* swap p1-p3 */
                t1 = (POINT2D*)p3;
                t3 = (POINT2D*)p1;
                p1 = (POINT4D*)t1;
                p3 = (POINT4D*)t3;
                p2_side = 1;
                reverse = 1;
        }
 
        radius = lw_arc_center(t1, t2, t3, &center);
        LWDEBUGF(2, " center is POINT(%.15g %.15g) - radius:%g", center.x, center.y, radius);
 
        /* Matched start/end points imply circle */
        if ( p1->x == p3->x && p1->y == p3->y )
                is_circle = LW_TRUE;
 
        /* Negative radius signals straight line, p1/p2/p3 are collinear */
        if ( (radius < 0.0 || p2_side == 0) && ! is_circle )
            return 0;
 
        /* The side of the p1/p3 line that p2 falls on dictates the sweep
           direction from p1 to p3. */
        if ( p2_side == -1 )
                clockwise = LW_TRUE;
        else
                clockwise = LW_FALSE;
 
        /* Compute the increment (angle per segment) depending on
         * our tolerance type. */
        switch(tolerance_type)
        {
                case LW_LINEARIZE_TOLERANCE_TYPE_SEGS_PER_QUAD:
                        increment = angle_increment_using_segments_per_quad(tol);
                        break;
                case LW_LINEARIZE_TOLERANCE_TYPE_MAX_DEVIATION:
                        increment = angle_increment_using_max_deviation(tol, radius);
                        break;
                case LW_LINEARIZE_TOLERANCE_TYPE_MAX_ANGLE:
                        increment = angle_increment_using_max_angle(tol);
                        break;
                default:
                        lwerror("lwarc_linearize: unsupported tolerance type %d", tolerance_type);
                        return -1;
        }
 
        if (increment < 0)
        {
                /* Error occurred in increment calculation somewhere
                 * (lwerror already called)
                 */
                return -1;
        }
 
        /* Angles of each point that defines the arc section */
        a1 = atan2(p1->y - center.y, p1->x - center.x);
        a2 = atan2(p2->y - center.y, p2->x - center.x);
        a3 = atan2(p3->y - center.y, p3->x - center.x);
 
        LWDEBUGF(2, "lwarc_linearize A1:%g (%g) A2:%g (%g) A3:%g (%g)",
                a1, a1*180/M_PI, a2, a2*180/M_PI, a3, a3*180/M_PI);
 
        /* Calculate total arc angle, in radians */
        double total_angle = clockwise ? a1 - a3 : a3 - a1;
        if ( total_angle <= 0 ) total_angle += M_PI * 2;
 
        /* At extreme tolerance values (very low or very high, depending on
         * the semantic) we may cause our arc to collapse. In this case,
         * we want shrink the increment enough so that we get two segments
         * for a standard arc, or three segments for a complete circle. */
        int min_segs = is_circle ? 3 : 2;
        segments = ceil(total_angle / increment);
        if (segments < min_segs)
        {
                segments = min_segs;
                increment = total_angle / min_segs;
        }
 
        if ( flags & LW_LINEARIZE_FLAG_SYMMETRIC )
        {
                LWDEBUGF(2, "lwarc_linearize SYMMETRIC requested - total angle %g deg", total_angle * 180 / M_PI);
 
                if ( flags & LW_LINEARIZE_FLAG_RETAIN_ANGLE )
                {
                        /* Number of complete steps */
                        segments = trunc(total_angle / increment);
 
                        /* Figure out the angle remainder, i.e. the amount of the angle
                         * that is left after we can take no more complete angle
                         * increments. */
                        double angle_remainder = total_angle - (increment * segments);
 
                        /* Shift the starting angle by half of the remainder. This
                         * will have the effect of evenly distributing the remainder
                         * among the first and last segments in the arc. */
                        angle_shift = angle_remainder / 2.0;
 
                        LWDEBUGF(2,
                                 "lwarc_linearize RETAIN_ANGLE operation requested - "
                                 "total angle %g, steps %d, increment %g, remainder %g",
                                 total_angle * 180 / M_PI,
                                 segments,
                                 increment * 180 / M_PI,
                                 angle_remainder * 180 / M_PI);
                }
                else
                {
                        /* Number of segments in output */
                        segments = ceil(total_angle / increment);
                        /* Tweak increment to be regular for all the arc */
                        increment = total_angle / segments;
 
                        LWDEBUGF(2,
                                 "lwarc_linearize SYMMETRIC operation requested - "
                                 "total angle %g degrees - LINESTRING(%g %g,%g %g,%g %g) - S:%d -   I:%g",
                                 total_angle * 180 / M_PI,
                                 p1->x,
                                 p1->y,
                                 center.x,
                                 center.y,
                                 p3->x,
                                 p3->y,
                                 segments,
                                 increment * 180 / M_PI);
                }
        }
 
        /* p2 on left side => clockwise sweep */
        if ( clockwise )
        {
                LWDEBUG(2, " Clockwise sweep");
                increment *= -1;
                angle_shift *= -1;
                /* Adjust a3 down so we can decrement from a1 to a3 cleanly */
                if ( a3 > a1 )
                        a3 -= 2.0 * M_PI;
                if ( a2 > a1 )
                        a2 -= 2.0 * M_PI;
        }
        /* p2 on right side => counter-clockwise sweep */
        else
        {
                LWDEBUG(2, " Counterclockwise sweep");
                /* Adjust a3 up so we can increment from a1 to a3 cleanly */
                if ( a3 < a1 )
                        a3 += 2.0 * M_PI;
                if ( a2 < a1 )
                        a2 += 2.0 * M_PI;
        }
 
        /* Override angles for circle case */
        if( is_circle )
        {
                increment = fabs(increment);
                segments = ceil(total_angle / increment);
                if (segments < 3)
                {
                        segments = 3;
                        increment = total_angle / 3;
                }
                a3 = a1 + 2.0 * M_PI;
                a2 = a1 + M_PI;
                clockwise = LW_FALSE;
                angle_shift = 0.0;
        }
 
        LWDEBUGF(2, "lwarc_linearize angle_shift:%g, increment:%g",
                angle_shift * 180/M_PI, increment * 180/M_PI);
 
        if ( reverse )
        {
                /* Append points in order to a temporary POINTARRAY and
                 * reverse them before writing to the output POINTARRAY. */
                const int capacity = 8; /* TODO: compute exactly ? */
                pa = ptarray_construct_empty(ptarray_has_z(to), ptarray_has_m(to), capacity);
        }
        else
        {
                /* Append points directly to the output POINTARRAY,
                 * starting with p1. */
                pa = to;
 
                ptarray_append_point(pa, p1, LW_FALSE);
                ++points_added;
        }
 
        /* Sweep from a1 to a3 */
        int seg_start = 1; /* First point is added manually */
        int seg_end = segments;
        if (angle_shift != 0.0)
        {
                /* When we have extra angles we need to add the extra segments at the
                 * start and end that cover those parts of the arc */
                seg_start = 0;
                seg_end = segments + 1;
        }
        LWDEBUGF(2, "a1:%g (%g deg), a3:%g (%g deg), inc:%g, shi:%g, cw:%d",
                a1, a1 * 180 / M_PI, a3, a3 * 180 / M_PI, increment, angle_shift, clockwise);
        for (int s = seg_start; s < seg_end; s++)
        {
                double angle = a1 + increment * s + angle_shift;
                LWDEBUGF(2, " SA: %g ( %g deg )", angle, angle*180/M_PI);
                pt.x = center.x + radius * cos(angle);
                pt.y = center.y + radius * sin(angle);
                pt.z = interpolate_arc(angle, a1, a2, a3, p1->z, p2->z, p3->z);
                pt.m = interpolate_arc(angle, a1, a2, a3, p1->m, p2->m, p3->m);
                ptarray_append_point(pa, &pt, LW_FALSE);
                ++points_added;
        }
 
        /* Ensure the final point is EXACTLY the same as the first for the circular case */
        if ( is_circle )
        {
                ptarray_remove_point(pa, pa->npoints - 1);
                ptarray_append_point(pa, p1, LW_FALSE);
        }
 
        if ( reverse )
        {
                int i;
                ptarray_append_point(to, p3, LW_FALSE);
                for ( i=pa->npoints; i>0; i-- ) {
                        getPoint4d_p(pa, i-1, &pt);
                        ptarray_append_point(to, &pt, LW_FALSE);
                }
                ptarray_free(pa);
        }
 
        return points_added;
}

References angle_increment_using_max_angle(), angle_increment_using_max_deviation(), angle_increment_using_segments_per_quad(), getPoint4d_p(), interpolate_arc(), lw_arc_center(), LW_FALSE, LW_LINEARIZE_FLAG_RETAIN_ANGLE, LW_LINEARIZE_FLAG_SYMMETRIC, LW_LINEARIZE_TOLERANCE_TYPE_MAX_ANGLE, LW_LINEARIZE_TOLERANCE_TYPE_MAX_DEVIATION, LW_LINEARIZE_TOLERANCE_TYPE_SEGS_PER_QUAD, lw_segment_side(), LW_TRUE, LWDEBUG, LWDEBUGF, lwerror(), POINT4D::m, POINTARRAY::npoints, ptarray_append_point(), ptarray_construct_empty(), ptarray_free(), ptarray_has_m(), ptarray_has_z(), ptarray_remove_point(), s, POINT2D::x, POINT4D::x, POINT2D::y, POINT4D::y, and POINT4D::z.

Referenced by lwcircstring_linearize().

Here is the call graph for this function:

Here is the caller graph for this function: