lwgeom_calculate_mbc()

LWBOUNDINGCIRCLE* lwgeom_calculate_mbc

(

const LWGEOM *

g

)

Definition at line 237 of file lwboundingcircle.c.

References calculate_mbc(), LW_FAILURE, lwalloc(), lwboundingcircle_create(), lwfree(), lwgeom_count_vertices(), lwgeom_is_empty(), lwpointiterator_create(), lwpointiterator_destroy(), lwpointiterator_next(), supporting_points_create(), supporting_points_destroy(), POINT2D::x, POINT4D::x, POINT2D::y, and POINT4D::y.

Referenced by mbc_test(), ST_MinimumBoundingCircle(), ST_MinimumBoundingRadius(), and test_empty().

{
        SUPPORTING_POINTS* support;
        LWBOUNDINGCIRCLE* result;
        LWPOINTITERATOR* it;
        uint32_t num_points;
        POINT2D** points;
        POINT4D p;
        uint32_t i;
        int success;

        if(g == NULL || lwgeom_is_empty(g))
                return LW_FAILURE;

        num_points = lwgeom_count_vertices(g);
        it = lwpointiterator_create(g);
        points = lwalloc(num_points * sizeof(POINT2D*));
        for (i = 0; i < num_points; i++)
        {
                if(!lwpointiterator_next(it, &p))
                {
                        uint32_t j;
                        for (j = 0; j < i; j++)
                        {
                                lwfree(points[j]);
                        }
                        lwpointiterator_destroy(it);
                        lwfree(points);
                        return LW_FAILURE;
                }

                points[i] = lwalloc(sizeof(POINT2D));
                points[i]->x = p.x;
                points[i]->y = p.y;
        }
        lwpointiterator_destroy(it);

        support = supporting_points_create();
        result = lwboundingcircle_create();
        /* Technically, a randomized algorithm would demand that we shuffle the input points
         * before we call calculate_mbc().  However, we make the (perhaps poor) assumption that
         * the order we happen to find the points is as good as random, or close enough.
         * */
        success = calculate_mbc((const POINT2D**) points, num_points, support, result);

        for (i = 0; i < num_points; i++)
        {
                lwfree(points[i]);
        }
        lwfree(points);
        supporting_points_destroy(support);

        if (!success)
                return NULL;

        return result;
}

Here is the call graph for this function:

Here is the caller graph for this function: