do_median_test()

static void do_median_test ( char *  input, char *  expected, int  fail_if_not_converged, int  iter_count  )

static

Definition at line 1399 of file cu_algorithm.c.

{
        cu_error_msg_reset();
        LWGEOM* g = lwgeom_from_wkt(input, LW_PARSER_CHECK_NONE);
        LWPOINT* expected_result = NULL;
        POINT4D actual_pt;
        POINT4D expected_pt;
        const double tolerance = FP_TOLERANCE / 10.0;
 
        LWPOINT* result = lwgeom_median(g, tolerance, iter_count, fail_if_not_converged);
        int passed = LW_FALSE;
 
        if (expected != NULL)
        {
                expected_result = lwgeom_as_lwpoint(lwgeom_from_wkt(expected, LW_PARSER_CHECK_NONE));
                lwpoint_getPoint4d_p(expected_result, &expected_pt);
        }
        if (result != NULL)
        {
                lwpoint_getPoint4d_p(result, &actual_pt);
        }
 
        if (result != NULL && expected != NULL) /* got something, expecting something */
        {
                passed = LW_TRUE;
                passed = passed && lwgeom_is_empty((LWGEOM*) expected_result) == lwgeom_is_empty((LWGEOM*) result);
                passed = passed && (lwgeom_has_z((LWGEOM*) expected_result) == lwgeom_has_z((LWGEOM*) result));
 
                if (passed && !lwgeom_is_empty((LWGEOM*) result))
                {
                        if (g->type == POINTTYPE)
                        {
                                passed &= fabs(actual_pt.x - expected_pt.x) < tolerance;
                                passed &= fabs(actual_pt.y - expected_pt.y) < tolerance;
                                passed &= (!lwgeom_has_z((LWGEOM*) expected_result) || fabs(actual_pt.z - expected_pt.z) < tolerance);
                                passed &= (!lwgeom_has_m((LWGEOM*) expected_result) || fabs(actual_pt.m - expected_pt.m) < tolerance);
                        }
                        else
                        {
                                /* Check that the difference between the obtained geometric
                                median and the expected point is within tolerance */
                                uint32_t npoints = 1;
                                int input_empty = LW_TRUE;
                                POINT4D* points = lwmpoint_extract_points_4d(lwgeom_as_lwmpoint(g), &npoints, &input_empty);
                                double distance_expected = test_weighted_distance(&expected_pt, points, npoints);
                                double distance_result = test_weighted_distance(&actual_pt, points, npoints);
 
                                passed = distance_result <= (1.0 + tolerance) * distance_expected;
                                if (!passed)
                                {
                                        printf("Diff: Got %.10f Expected %.10f\n", distance_result, distance_expected);
                                }
                                lwfree(points);
                        }
                }
 
                if (!passed)
                {
                        printf("median_test input %s (parsed %s) expected %s got %s\n",
                                input, lwgeom_to_ewkt(g),
                                lwgeom_to_ewkt((LWGEOM*) expected_result),
                                lwgeom_to_ewkt((LWGEOM*) result));
                }
 
        }
        else if (result == NULL && expected == NULL) /* got nothing, expecting nothing */
        {
                passed = LW_TRUE;
        }
        else if (result != NULL && expected == NULL) /* got something, expecting nothing */
        {
                passed = LW_FALSE;
                printf("median_test input %s (parsed %s) expected NULL got %s\n", input, lwgeom_to_ewkt(g), lwgeom_to_ewkt((LWGEOM*) result));
        }
        else if (result == NULL && expected != NULL) /* got nothing, expecting something */
        {
                passed = LW_FALSE;
                printf("%s", cu_error_msg);
                printf("median_test input %s (parsed %s) expected %s got NULL\n", input, lwgeom_to_ewkt(g), lwgeom_to_ewkt((LWGEOM*) expected_result));
        }
 
        CU_ASSERT_TRUE(passed);
 
        lwgeom_free(g);
        lwpoint_free(expected_result);
        lwpoint_free(result);
}

References cu_error_msg, cu_error_msg_reset(), FP_TOLERANCE, LW_FALSE, LW_PARSER_CHECK_NONE, LW_TRUE, lwfree(), lwgeom_as_lwmpoint(), lwgeom_as_lwpoint(), lwgeom_free(), lwgeom_from_wkt(), lwgeom_has_m(), lwgeom_has_z(), lwgeom_is_empty(), lwgeom_median(), lwgeom_to_ewkt(), lwmpoint_extract_points_4d(), lwpoint_free(), lwpoint_getPoint4d_p(), POINT4D::m, POINTTYPE, result, test_weighted_distance(), LWGEOM::type, POINT4D::x, POINT4D::y, and POINT4D::z.

Referenced by test_median_robustness().

Here is the call graph for this function:

Here is the caller graph for this function: