static void
_adg_property_level(void)
{
AdgDim *dim;
gdouble valid_value_1, valid_value_2;
gdouble level;
dim = ADG_DIM(adg_ldim_new());
valid_value_1 = 4321;
valid_value_2 = 1234;
/* Using the public APIs */
adg_dim_set_level(dim, valid_value_1);
level = adg_dim_get_level(dim);
adg_assert_isapprox(level, valid_value_1);
adg_dim_set_level(dim, valid_value_2);
level = adg_dim_get_level(dim);
adg_assert_isapprox(level, valid_value_2);
/* Using GObject property methods */
g_object_set(dim, "level", valid_value_1, NULL);
g_object_get(dim, "level", &level, NULL);
adg_assert_isapprox(level, valid_value_1);
g_object_set(dim, "level", valid_value_2, NULL);
g_object_get(dim, "level", &level, NULL);
adg_assert_isapprox(level, valid_value_2);
adg_entity_destroy(ADG_ENTITY(dim));
}
static void
_cpml_method_put_intersections(void)
{
CpmlSegment segment;
CpmlPrimitive primitive1, primitive2;
CpmlPair pair[2];
/* Set primitive1 to 1.1 (first segment, first primitive) */
cpml_segment_from_cairo(&segment, (cairo_path_t *) adg_test_path());
cpml_primitive_from_segment(&primitive1, &segment);
/* Set primitive2 to 2.1 (second segment, first primitive) */
cpml_segment_next(&segment);
cpml_primitive_from_segment(&primitive2, &segment);
/* primitive1 (1.1) does not intersect primitive2 (2.1) */
g_assert_cmpuint(cpml_primitive_put_intersections(&primitive1, &primitive2, 2, pair), ==, 0);
cpml_primitive_next(&primitive2);
/* primitive1 (1.1) intersects primitive2 (2.2) in (1, 1) */
g_assert_cmpuint(cpml_primitive_put_intersections(&primitive1, &primitive2, 2, pair), ==, 1);
adg_assert_isapprox(pair[0].x, 1);
adg_assert_isapprox(pair[0].y, 1);
g_assert_cmpint(cpml_primitive_is_inside(&primitive1, pair), ==, 1);
g_assert_cmpint(cpml_primitive_is_inside(&primitive2, pair), ==, 1);
/* Check the intersection is not returned when not requested */
g_assert_cmpuint(cpml_primitive_put_intersections(&primitive1, &primitive2, 0, pair), ==, 0);
cpml_primitive_next(&primitive1);
/* primitive1 (1.2) does not intersect primitive2 (2.2) */
g_assert_cmpuint(cpml_primitive_put_intersections(&primitive1, &primitive2, 2, pair), ==, 0);
cpml_primitive_next(&primitive1);
/* primitive1 (1.3) does not intersect primitive2 (2.2) */
g_assert_cmpuint(cpml_primitive_put_intersections(&primitive1, &primitive2, 2, pair), ==, 0);
cpml_primitive_next(&primitive1);
/* primitive1 (1.4) intersects primitive2 (2.2), but outside their boundaries */
g_assert_cmpuint(cpml_primitive_put_intersections(&primitive1, &primitive2, 2, pair), ==, 1);
adg_assert_isapprox(pair[0].x, 1);
adg_assert_isapprox(pair[0].y, -1);
g_assert_cmpint(cpml_primitive_is_inside(&primitive1, pair), ==, 0);
g_assert_cmpint(cpml_primitive_is_inside(&primitive2, pair), ==, 0);
}
static void
_cpml_method_get_length(void)
{
CpmlSegment segment;
CpmlPrimitive primitive;
cpml_segment_from_cairo(&segment, (cairo_path_t *) adg_test_path());
cpml_segment_next(&segment);
cpml_primitive_from_segment(&primitive, &segment);
adg_assert_isapprox(cpml_primitive_get_length(&primitive), 1);
cpml_primitive_next(&primitive);
adg_assert_isapprox(cpml_primitive_get_length(&primitive), 2);
}
static void
_cpml_method_copy_data(void)
{
CpmlSegment segment;
CpmlPrimitive original, *primitive;
int n;
cpml_segment_from_cairo(&segment, (cairo_path_t *) adg_test_path());
cpml_primitive_from_segment(&original, &segment);
/* Check incompatible primitives are not copied */
primitive = cpml_primitive_deep_dup(&original);
++primitive->data[0].header.length;
g_assert_cmpint(cpml_primitive_copy_data(primitive, &original), ==, 0);
--primitive->data[0].header.length;
++primitive->data[0].header.type;
g_assert_cmpint(cpml_primitive_copy_data(primitive, &original), ==, 0);
--primitive->data[0].header.type;
do {
primitive = cpml_primitive_deep_dup(&original);
++primitive->org->point.x;
++primitive->org->point.y;
for (n = 1; n < primitive->data[0].header.length; ++n) {
++primitive->data[n].point.x;
++primitive->data[n].point.y;
}
g_assert_cmpfloat(primitive->org->point.x, !=, original.org->point.x);
g_assert_cmpfloat(primitive->org->point.y, !=, original.org->point.y);
for (n = 1; n < primitive->data[0].header.length; ++n) {
g_assert_cmpfloat(primitive->data[n].point.x, !=, original.data[n].point.x);
g_assert_cmpfloat(primitive->data[n].point.y, !=, original.data[n].point.y);
}
g_assert_cmpint(cpml_primitive_copy_data(primitive, &original), ==, 1);
adg_assert_isapprox(primitive->org->point.x, original.org->point.x);
adg_assert_isapprox(primitive->org->point.y, original.org->point.y);
for (n = 1; n < primitive->data[0].header.length; ++n) {
adg_assert_isapprox(primitive->data[n].point.x, original.data[n].point.x);
adg_assert_isapprox(primitive->data[n].point.y, original.data[n].point.y);
}
g_free(primitive);
} while (cpml_primitive_next(&original));
}
static void
_adg_behavior_entity(void)
{
AdgCanvas *canvas;
const CpmlExtents *extents;
AdgTitleBlock *title_block;
canvas = ADG_CANVAS(adg_test_canvas());
adg_entity_arrange(ADG_ENTITY(canvas));
extents = adg_entity_get_extents(ADG_ENTITY(canvas));
g_assert_true(extents->is_defined);
adg_assert_isapprox(extents->size.x, 1);
adg_assert_isapprox(extents->size.y, 1);
adg_entity_invalidate(ADG_ENTITY(canvas));
extents = adg_entity_get_extents(ADG_ENTITY(canvas));
g_assert_false(extents->is_defined);
title_block = adg_title_block_new();
adg_canvas_set_title_block(canvas, title_block);
adg_entity_arrange(ADG_ENTITY(canvas));
extents = adg_entity_get_extents(ADG_ENTITY(canvas));
g_assert_true(extents->is_defined);
g_assert_cmpfloat(extents->size.x, >, 1);
g_assert_cmpfloat(extents->size.y, >, 1);
g_assert_cmpfloat(extents->size.x, <, 5000);
g_assert_cmpfloat(extents->size.y, <, 5000);
adg_canvas_set_size_explicit(canvas, 5000, 5000);
adg_entity_arrange(ADG_ENTITY(canvas));
extents = adg_entity_get_extents(ADG_ENTITY(canvas));
g_assert_true(extents->is_defined);
adg_assert_isapprox(extents->size.x, 5000);
adg_assert_isapprox(extents->size.y, 5000);
adg_entity_destroy(ADG_ENTITY(canvas));
}
static void
_cpml_behavior_browsing(void)
{
CpmlSegment segment;
CpmlPrimitive primitive, primitive_copy;
cpml_segment_from_cairo(&segment, (cairo_path_t *) adg_test_path());
cpml_primitive_from_segment(&primitive, &segment);
adg_assert_isapprox((primitive.org)->point.x, 0);
adg_assert_isapprox((primitive.org)->point.y, 1);
g_assert_cmpint((primitive.data)->header.type, ==, CPML_LINE);
g_assert_true(cpml_primitive_next(&primitive));
adg_assert_isapprox((primitive.org)->point.x, 3);
adg_assert_isapprox((primitive.org)->point.y, 1);
g_assert_cmpint((primitive.data)->header.type, ==, CPML_ARC);
g_assert_true(cpml_primitive_next(&primitive));
adg_assert_isapprox((primitive.org)->point.x, 6);
adg_assert_isapprox((primitive.org)->point.y, 7);
g_assert_cmpint((primitive.data)->header.type, ==, CPML_CURVE);
g_assert_true(cpml_primitive_next(&primitive));
adg_assert_isapprox((primitive.org)->point.x, -2);
adg_assert_isapprox((primitive.org)->point.y, 2);
g_assert_cmpint((primitive.data)->header.type, ==, CPML_CLOSE);
g_assert_false(cpml_primitive_next(&primitive));
cpml_primitive_reset(&primitive);
g_assert_true(cpml_primitive_next(&primitive));
cpml_primitive_reset(&primitive);
cpml_primitive_reset(&primitive);
g_assert_true(cpml_primitive_next(&primitive));
g_assert_true(cpml_primitive_next(&primitive));
g_assert_true(cpml_primitive_next(&primitive));
g_assert_false(cpml_primitive_next(&primitive));
cpml_primitive_copy(&primitive_copy, &primitive);
g_assert_false(cpml_primitive_next(&primitive_copy));
cpml_primitive_reset(&primitive);
g_assert_false(cpml_primitive_next(&primitive_copy));
cpml_primitive_reset(&primitive_copy);
g_assert_true(cpml_primitive_next(&primitive_copy));
}
static void
_cpml_method_put_intersections_with_segment(void)
{
CpmlSegment segment;
CpmlPrimitive primitive;
CpmlPair pair[4];
/* Set primitive to first segment, first primitive */
cpml_segment_from_cairo(&segment, (cairo_path_t *) adg_test_path());
cpml_primitive_from_segment(&primitive, &segment);
/* Set segment to the second segment */
cpml_segment_next(&segment);
/* primitive (1.1) intersects segment (2) in (1, 1) */
g_assert_cmpuint(cpml_primitive_put_intersections_with_segment(&primitive, &segment, 4, pair), ==, 1);
adg_assert_isapprox(pair[0].x, 1);
adg_assert_isapprox(pair[0].y, 1);
cpml_primitive_next(&primitive);
/* primitive (1.1) does not intersect segment (2) */
g_assert_cmpuint(cpml_primitive_put_intersections_with_segment(&primitive, &segment, 4, pair), ==, 0);
/* Set primitive to second segment, first primitive */
cpml_primitive_from_segment(&primitive, &segment);
/* Set segment to the first segment */
cpml_segment_reset(&segment);
/* primitive (2.1) intersects segment (1) in extrapolation.
* TODO: change this behavior! They must not intersect. */
g_assert_cmpuint(cpml_primitive_put_intersections_with_segment(&primitive, &segment, 4, pair), ==, 1);
adg_assert_isapprox(pair[0].x, 2);
adg_assert_isapprox(pair[0].y, 0);
cpml_primitive_next(&primitive);
/* primitive (2.2) wrongly intersects segment (1) */
g_assert_cmpuint(cpml_primitive_put_intersections_with_segment(&primitive, &segment, 4, pair), ==, 1);
adg_assert_isapprox(pair[0].x, 2);
adg_assert_isapprox(pair[0].y, 0);
}
static void
_adg_behavior_named_pair(void)
{
CpmlPair p1 = { 123, 456 };
AdgPoint *explicit_point, *explicit_point2, *model_point;
AdgModel *model;
CpmlPair *pair;
explicit_point = adg_point_new();
g_assert_nonnull(explicit_point);
adg_point_set_pair(explicit_point, &p1);
explicit_point2 = adg_point_new();
g_assert_nonnull(explicit_point2);
adg_point_set_pair_explicit(explicit_point2, p1.x, p1.y);
/* Checking comparison APIs */
g_assert_true(adg_point_equal(explicit_point, explicit_point2));
adg_point_set_pair_explicit(explicit_point2, 78, 90);
g_assert_false(adg_point_equal(explicit_point, explicit_point2));
pair = (CpmlPair *) explicit_point2;
adg_assert_isapprox(pair->x, 78);
adg_assert_isapprox(pair->y, 90);
pair = adg_point_get_pair(explicit_point);
g_assert_true(cpml_pair_equal(pair, &p1));
g_free(pair);
model = ADG_MODEL(adg_path_new());
g_assert_nonnull(model);
adg_model_set_named_pair(model, "named-pair", &p1);
model_point = adg_point_new();
g_assert_nonnull(model_point);
adg_point_set_pair_from_model(model_point, model, "named-pair");
pair = adg_point_get_pair(model_point);
g_assert_true(cpml_pair_equal(pair, &p1));
g_free(pair);
/* Ensure ADG does not consider an explicit point equals to
* a point bound to a named pair with the same coordinates */
g_assert_false(adg_point_equal(explicit_point, model_point));
/* Check for lazy evaluation of named pairs */
adg_point_set_pair_from_model(model_point, model, "unexistent-pair");
pair = (CpmlPair *) model_point;
adg_assert_isapprox(pair->x, p1.x);
adg_assert_isapprox(pair->y, p1.y);
/* Check behavior on undefined named pair */
g_assert_false(adg_point_update(model_point));
g_assert_null(adg_point_get_pair(model_point));
adg_point_set_pair_from_model(model_point, model, "named-pair");
g_assert_true(adg_point_update(model_point));
/* Check for case sensitiveness */
adg_point_set_pair_from_model(model_point, model, "Named-Pair");
g_assert_null(adg_point_get_pair(model_point));
g_assert_false(adg_point_update(model_point));
/* Check if adg_point_get_pair() triggers an adg_point_update() */
adg_point_set_pair_from_model(model_point, model, "named-pair");
pair = adg_point_get_pair(model_point);
g_assert_true(cpml_pair_equal(pair, &p1));
g_free(pair);
adg_point_destroy(explicit_point);
adg_point_destroy(model_point);
g_object_unref(model);
}
static void
_adg_behavior_misc(void)
{
AdgPoint *point, *dup_point;
CpmlPair *pair, *dup_pair;
CpmlPair dummy_pair = { 3.4, 5.6 };
point = adg_point_new();
g_assert_nonnull(point);
adg_point_set_pair_explicit(point, 1, 2);
pair = (CpmlPair *) point;
adg_assert_isapprox(pair->x, 1);
adg_assert_isapprox(pair->y, 2);
pair = adg_point_get_pair(point);
g_assert_nonnull(pair);
adg_assert_isapprox(pair->x, 1);
adg_assert_isapprox(pair->y, 2);
dup_point = adg_point_dup(point);
g_assert_nonnull(dup_point);
g_assert_true(dup_point != point);
/* Should be a noop with explicit pairs */
adg_point_invalidate(point);
dup_pair = adg_point_get_pair(dup_point);
g_assert_nonnull(dup_pair);
g_assert_true(dup_pair != pair);
adg_assert_isapprox(pair->x, dup_pair->x);
adg_assert_isapprox(pair->y, dup_pair->y);
g_assert_true(adg_point_equal(point, dup_point));
g_free(dup_pair);
adg_point_destroy(dup_point);
dup_point = adg_point_new();
adg_point_set_pair(dup_point, &dummy_pair);
dup_pair = (CpmlPair *) dup_point;
/* Should be a noop with explicit pairs */
adg_point_invalidate(dup_point);
adg_assert_isapprox(dup_pair->x, 3.4);
adg_assert_isapprox(dup_pair->y, 5.6);
g_assert_false(adg_point_equal(point, dup_point));
adg_point_copy(dup_point, point);
dup_pair = adg_point_get_pair(dup_point);
g_assert_nonnull(dup_pair);
g_assert_nonnull(dup_pair);
adg_assert_isapprox(pair->x, dup_pair->x);
adg_assert_isapprox(pair->y, dup_pair->y);
g_assert_true(adg_point_equal(point, dup_point));
g_free(pair);
g_free(dup_pair);
adg_point_destroy(point);
adg_point_destroy(dup_point);
}
static void
_cpml_method_put_point(void)
{
CpmlSegment segment;
CpmlPrimitive primitive;
CpmlPair pair;
cpml_segment_from_cairo(&segment, (cairo_path_t *) adg_test_path());
/* Line */
cpml_primitive_from_segment(&primitive, &segment);
cpml_primitive_put_point(&primitive, 0, &pair);
adg_assert_isapprox(pair.x, 0);
adg_assert_isapprox(pair.y, 1);
cpml_primitive_put_point(&primitive, 1, &pair);
adg_assert_isapprox(pair.x, 3);
adg_assert_isapprox(pair.y, 1);
cpml_primitive_put_point(&primitive, 2, &pair);
adg_assert_isapprox(pair.x, 3);
adg_assert_isapprox(pair.y, 1);
/* The negative indices are checked only against CPML_LINE */
cpml_primitive_put_point(&primitive, -1, &pair);
adg_assert_isapprox(pair.x, 3);
adg_assert_isapprox(pair.y, 1);
cpml_primitive_put_point(&primitive, -2, &pair);
adg_assert_isapprox(pair.x, 0);
adg_assert_isapprox(pair.y, 1);
cpml_primitive_put_point(&primitive, -3, &pair);
adg_assert_isapprox(pair.x, 0);
adg_assert_isapprox(pair.y, 1);
/* Arc */
cpml_primitive_next(&primitive);
cpml_primitive_put_point(&primitive, 0, &pair);
adg_assert_isapprox(pair.x, 3);
adg_assert_isapprox(pair.y, 1);
cpml_primitive_put_point(&primitive, 1, &pair);
adg_assert_isapprox(pair.x, 4);
adg_assert_isapprox(pair.y, 5);
cpml_primitive_put_point(&primitive, 2, &pair);
adg_assert_isapprox(pair.x, 6);
adg_assert_isapprox(pair.y, 7);
cpml_primitive_put_point(&primitive, 3, &pair);
adg_assert_isapprox(pair.x, 6);
adg_assert_isapprox(pair.y, 7);
/* Curve */
cpml_primitive_next(&primitive);
cpml_primitive_put_point(&primitive, 0, &pair);
adg_assert_isapprox(pair.x, 6);
adg_assert_isapprox(pair.y, 7);
cpml_primitive_put_point(&primitive, 1, &pair);
adg_assert_isapprox(pair.x, 8);
adg_assert_isapprox(pair.y, 9);
cpml_primitive_put_point(&primitive, 2, &pair);
adg_assert_isapprox(pair.x, 10);
adg_assert_isapprox(pair.y, 11);
cpml_primitive_put_point(&primitive, 3, &pair);
adg_assert_isapprox(pair.x, -2);
adg_assert_isapprox(pair.y, 2);
cpml_primitive_put_point(&primitive, 4, &pair);
adg_assert_isapprox(pair.x, -2);
adg_assert_isapprox(pair.y, 2);
/* Close */
cpml_primitive_next(&primitive);
cpml_primitive_put_point(&primitive, 0, &pair);
adg_assert_isapprox(pair.x, -2);
adg_assert_isapprox(pair.y, 2);
cpml_primitive_put_point(&primitive, 1, &pair);
adg_assert_isapprox(pair.x, 0);
adg_assert_isapprox(pair.y, 1);
cpml_primitive_put_point(&primitive, 2, &pair);
adg_assert_isapprox(pair.x, 0);
adg_assert_isapprox(pair.y, 1);
}
static void
_cpml_method_set_point(void)
{
gsize data_size;
CpmlSegment original, *segment;
CpmlPrimitive primitive;
CpmlPair pair, pair2;
int equality;
/* Work on a copy to not modify the original path data */
cpml_segment_from_cairo(&original, (cairo_path_t *) adg_test_path());
data_size = original.num_data * sizeof(cairo_path_data_t);
segment = cpml_segment_deep_dup(&original);
/* Line */
cpml_primitive_from_segment(&primitive, segment);
equality = memcmp(original.data, segment->data, data_size);
g_assert_cmpint(equality, ==, 0);
cpml_primitive_put_point(&primitive, 0, &pair);
pair.x += 1;
cpml_primitive_set_point(&primitive, 0, &pair);
equality = memcmp(original.data, segment->data, data_size);
g_assert_cmpint(equality, !=, 0);
pair.x -= 1;
cpml_primitive_set_point(&primitive, 0, &pair);
equality = memcmp(original.data, segment->data, data_size);
g_assert_cmpint(equality, ==, 0);
cpml_primitive_put_point(&primitive, 1, &pair);
pair.y += 1;
cpml_primitive_set_point(&primitive, 1, &pair);
equality = memcmp(original.data, segment->data, data_size);
g_assert_cmpint(equality, !=, 0);
/* On a CPML_LINE primitives, -1 and 1 indices are equals */
cpml_primitive_put_point(&primitive, -1, &pair2);
adg_assert_isapprox(pair.x, pair2.x);
adg_assert_isapprox(pair.y, pair2.y);
memcpy(segment->data, original.data, data_size);
equality = memcmp(original.data, segment->data, data_size);
g_assert_cmpint(equality, ==, 0);
cpml_primitive_put_point(&primitive, 2, &pair);
pair.x += 1;
pair.y += 1;
/* This should be a NOP without segfaults */
cpml_primitive_set_point(&primitive, 2, &pair);
equality = memcmp(original.data, segment->data, data_size);
g_assert_cmpint(equality, ==, 0);
/* From now on, memcpy() is assumed to force equality (as already
* proved by the previous assertions) and pair2 is used as a
* different-from-everything pair, that is setting pair2 on any
* point will break the equality between segment->data and
* original.data
*/
pair2.x = 12345;
pair2.y = 54321;
/* Arc */
cpml_primitive_next(&primitive);
cpml_primitive_set_point(&primitive, 0, &pair2);
equality = memcmp(original.data, segment->data, data_size);
g_assert_cmpint(equality, !=, 0);
memcpy(segment->data, original.data, data_size);
cpml_primitive_set_point(&primitive, 1, &pair2);
equality = memcmp(original.data, segment->data, data_size);
g_assert_cmpint(equality, !=, 0);
memcpy(segment->data, original.data, data_size);
cpml_primitive_set_point(&primitive, 2, &pair2);
equality = memcmp(original.data, segment->data, data_size);
g_assert_cmpint(equality, !=, 0);
memcpy(segment->data, original.data, data_size);
cpml_primitive_set_point(&primitive, 3, &pair2);
equality = memcmp(original.data, segment->data, data_size);
g_assert_cmpint(equality, ==, 0);
/* Curve */
cpml_primitive_next(&primitive);
cpml_primitive_set_point(&primitive, 0, &pair2);
equality = memcmp(original.data, segment->data, data_size);
g_assert_cmpint(equality, !=, 0);
memcpy(segment->data, original.data, data_size);
cpml_primitive_set_point(&primitive, 1, &pair2);
equality = memcmp(original.data, segment->data, data_size);
g_assert_cmpint(equality, !=, 0);
memcpy(segment->data, original.data, data_size);
cpml_primitive_set_point(&primitive, 2, &pair2);
equality = memcmp(original.data, segment->data, data_size);
g_assert_cmpint(equality, !=, 0);
memcpy(segment->data, original.data, data_size);
cpml_primitive_set_point(&primitive, 3, &pair2);
equality = memcmp(original.data, segment->data, data_size);
g_assert_cmpint(equality, !=, 0);
memcpy(segment->data, original.data, data_size);
cpml_primitive_set_point(&primitive, 4, &pair2);
equality = memcmp(original.data, segment->data, data_size);
g_assert_cmpint(equality, ==, 0);
/* Close */
cpml_primitive_next(&primitive);
cpml_primitive_set_point(&primitive, 0, &pair2);
equality = memcmp(original.data, segment->data, data_size);
g_assert_cmpint(equality, !=, 0);
memcpy(segment->data, original.data, data_size);
cpml_primitive_set_point(&primitive, 1, &pair2);
equality = memcmp(original.data, segment->data, data_size);
g_assert_cmpint(equality, !=, 0);
memcpy(segment->data, original.data, data_size);
cpml_primitive_set_point(&primitive, 2, &pair2);
equality = memcmp(original.data, segment->data, data_size);
g_assert_cmpint(equality, ==, 0);
g_free(segment);
}
static void
_cpml_method_get_closest_pos(void)
{
CpmlSegment segment;
CpmlPrimitive primitive;
CpmlPair pair;
cpml_segment_from_cairo(&segment, (cairo_path_t *) adg_test_path());
cpml_primitive_from_segment(&primitive, &segment);
/* Line */
pair.x = 0; pair.y = 1;
adg_assert_isapprox(cpml_primitive_get_closest_pos(&primitive, &pair), 0);
pair.x = 3; pair.y = 1;
adg_assert_isapprox(cpml_primitive_get_closest_pos(&primitive, &pair), 1);
pair.x = -1; pair.y = -1;
adg_assert_isapprox(cpml_primitive_get_closest_pos(&primitive, &pair), 0);
pair.x = 4; pair.y = 2;
adg_assert_isapprox(cpml_primitive_get_closest_pos(&primitive, &pair), 1);
pair.x = 1.5; pair.y = 0;
adg_assert_isapprox(cpml_primitive_get_closest_pos(&primitive, &pair), 0.5);
/* Arc */
cpml_primitive_next(&primitive);
/* TODO: not yet implemented
* pair.x = 3; pair.y = 1;
* adg_assert_isapprox(cpml_primitive_get_closest_pos(&primitive, &pair), 0);
* pair.x = 6; pair.y = 7;
* adg_assert_isapprox(cpml_primitive_get_closest_pos(&primitive, &pair), 1);
* pair.x = 0; pair.y = 0;
* adg_assert_isapprox(cpml_primitive_get_closest_pos(&primitive, &pair), 0);
* pair.x = 10; pair.y = 10;
* adg_assert_isapprox(cpml_primitive_get_closest_pos(&primitive, &pair), 1);
*/
/* Close */
cpml_primitive_next(&primitive);
/* TODO: not yet implemented
* pair.x = 6; pair.y = 7;
* adg_assert_isapprox(cpml_primitive_get_closest_pos(&primitive, &pair), 0);
* pair.x = -2; pair.y = 2;
* adg_assert_isapprox(cpml_primitive_get_closest_pos(&primitive, &pair), 1);
* pair.x = 10; pair.y = 10;
* adg_assert_isapprox(cpml_primitive_get_closest_pos(&primitive, &pair), 0);
* pair.x = 0; pair.y = 0;
* adg_assert_isapprox(cpml_primitive_get_closest_pos(&primitive, &pair), 1);
*/
/* Close */
cpml_primitive_next(&primitive);
pair.x = -2; pair.y = 2;
adg_assert_isapprox(cpml_primitive_get_closest_pos(&primitive, &pair), 0);
pair.x = 0; pair.y = 1;
adg_assert_isapprox(cpml_primitive_get_closest_pos(&primitive, &pair), 1);
pair.x = -3; pair.y = 3;
adg_assert_isapprox(cpml_primitive_get_closest_pos(&primitive, &pair), 0);
pair.x = 1; pair.y = 0;
adg_assert_isapprox(cpml_primitive_get_closest_pos(&primitive, &pair), 1);
pair.x = -1; pair.y = 1.5;
adg_assert_isapprox(cpml_primitive_get_closest_pos(&primitive, &pair), 0.5);
}
static void
_cpml_method_put_vector_at(void)
{
CpmlSegment segment;
CpmlPrimitive primitive;
CpmlVector vector;
cpml_segment_from_cairo(&segment, (cairo_path_t *) adg_test_path());
/* Line */
cpml_primitive_from_segment(&primitive, &segment);
cpml_primitive_put_vector_at(&primitive, 0, &vector);
adg_assert_isapprox(vector.x, 3);
adg_assert_isapprox(vector.y, 0);
cpml_primitive_put_vector_at(&primitive, 1, &vector);
adg_assert_isapprox(vector.x, 3);
adg_assert_isapprox(vector.y, 0);
cpml_primitive_put_vector_at(&primitive, 0.5, &vector);
adg_assert_isapprox(vector.x, 3);
adg_assert_isapprox(vector.y, 0);
/* Arc */
cpml_primitive_next(&primitive);
cpml_primitive_put_vector_at(&primitive, 0, &vector);
adg_assert_isapprox(vector.x, -0.077);
adg_assert_isapprox(vector.y, 0.997);
cpml_primitive_put_vector_at(&primitive, 1, &vector);
adg_assert_isapprox(vector.x, 0.844);
adg_assert_isapprox(vector.y, 0.537);
cpml_primitive_put_vector_at(&primitive, 0.5, &vector);
adg_assert_isapprox(vector.x, 0.447);
adg_assert_isapprox(vector.y, 0.894);
/* Close */
cpml_primitive_next(&primitive);
/* TODO: not yet implemented
* cpml_primitive_put_vector_at(&primitive, 0, &vector);
* adg_assert_isapprox(vector.x, 6);
* adg_assert_isapprox(vector.y, 7);
* cpml_primitive_put_vector_at(&primitive, 1, &vector);
* adg_assert_isapprox(vector.x, -2);
* adg_assert_isapprox(vector.y, 2);
* cpml_primitive_put_vector_at(&primitive, 0.5, &vector);
* adg_assert_isapprox(vector.x, 1);
* adg_assert_isapprox(vector.y, 1); */
/* Close */
cpml_primitive_next(&primitive);
cpml_primitive_put_vector_at(&primitive, 0, &vector);
adg_assert_isapprox(vector.x, 2);
adg_assert_isapprox(vector.y, -1);
cpml_primitive_put_vector_at(&primitive, 1, &vector);
adg_assert_isapprox(vector.x, 2);
adg_assert_isapprox(vector.y, -1);
cpml_primitive_put_vector_at(&primitive, 0.5, &vector);
adg_assert_isapprox(vector.x, 2);
adg_assert_isapprox(vector.y, -1);
}
static void
_cpml_method_put_pair_at(void)
{
CpmlSegment segment;
CpmlPrimitive primitive;
CpmlPair pair;
cpml_segment_from_cairo(&segment, (cairo_path_t *) adg_test_path());
/* Line */
cpml_primitive_from_segment(&primitive, &segment);
cpml_primitive_put_pair_at(&primitive, 0, &pair);
adg_assert_isapprox(pair.x, 0);
adg_assert_isapprox(pair.y, 1);
cpml_primitive_put_pair_at(&primitive, 1, &pair);
adg_assert_isapprox(pair.x, 3);
adg_assert_isapprox(pair.y, 1);
cpml_primitive_put_pair_at(&primitive, 0.5, &pair);
adg_assert_isapprox(pair.x, 1.5);
adg_assert_isapprox(pair.y, 1);
/* Arc */
cpml_primitive_next(&primitive);
cpml_primitive_put_pair_at(&primitive, 0, &pair);
adg_assert_isapprox(pair.x, 3);
adg_assert_isapprox(pair.y, 1);
cpml_primitive_put_pair_at(&primitive, 1, &pair);
adg_assert_isapprox(pair.x, 6);
adg_assert_isapprox(pair.y, 7);
cpml_primitive_put_pair_at(&primitive, 0.5, &pair);
adg_assert_isapprox(pair.x, 3.669);
adg_assert_isapprox(pair.y, 4.415);
/* Close */
cpml_primitive_next(&primitive);
/* TODO: not yet implemented
* cpml_primitive_put_pair_at(&primitive, 0, &pair);
* adg_assert_isapprox(pair.x, 6);
* adg_assert_isapprox(pair.y, 7);
* cpml_primitive_put_pair_at(&primitive, 1, &pair);
* adg_assert_isapprox(pair.x, -2);
* adg_assert_isapprox(pair.y, 2);
* cpml_primitive_put_pair_at(&primitive, 0.5, &pair);
* adg_assert_isapprox(pair.x, 1);
* adg_assert_isapprox(pair.y, 1); */
/* Close */
cpml_primitive_next(&primitive);
cpml_primitive_put_pair_at(&primitive, 0, &pair);
adg_assert_isapprox(pair.x, -2);
adg_assert_isapprox(pair.y, 2);
cpml_primitive_put_pair_at(&primitive, 1, &pair);
adg_assert_isapprox(pair.x, 0);
adg_assert_isapprox(pair.y, 1);
cpml_primitive_put_pair_at(&primitive, 0.5, &pair);
adg_assert_isapprox(pair.x, -1);
adg_assert_isapprox(pair.y, 1.5);
}
static void
_cpml_method_put_extents(void)
{
CpmlSegment segment;
CpmlPrimitive primitive;
CpmlExtents extents;
cpml_segment_from_cairo(&segment, (cairo_path_t *) adg_test_path());
/* Line */
cpml_primitive_from_segment(&primitive, &segment);
cpml_primitive_put_extents(&primitive, &extents);
g_assert_true(extents.is_defined);
adg_assert_isapprox(extents.org.x, 0);
adg_assert_isapprox(extents.org.y, 1);
adg_assert_isapprox(extents.size.x, 3);
adg_assert_isapprox(extents.size.y, 0);
/* Arc: the extents are computed precisely... let's ensure
* at least all the 3 points are included */
cpml_primitive_next(&primitive);
cpml_primitive_put_extents(&primitive, &extents);
g_assert_true(extents.is_defined);
g_assert_cmpfloat(extents.org.x, <=, 3);
g_assert_cmpfloat(extents.org.y, <=, 1);
g_assert_cmpfloat(extents.size.x, >=, 3);
g_assert_cmpfloat(extents.size.y, >=, 6);
/* Curve: actually the extents are computed by using the
* convex hull (hence the exact coordinates of the points) */
cpml_primitive_next(&primitive);
cpml_primitive_put_extents(&primitive, &extents);
g_assert_true(extents.is_defined);
adg_assert_isapprox(extents.org.x, -2);
adg_assert_isapprox(extents.org.y, 2);
adg_assert_isapprox(extents.size.x, 12);
adg_assert_isapprox(extents.size.y, 9);
/* Close */
cpml_primitive_next(&primitive);
cpml_primitive_put_extents(&primitive, &extents);
g_assert_true(extents.is_defined);
adg_assert_isapprox(extents.org.x, -2);
adg_assert_isapprox(extents.org.y, 1);
adg_assert_isapprox(extents.size.x, 2);
adg_assert_isapprox(extents.size.y, 1);
}
static void
_cpml_method_offset(void)
{
CpmlSegment original, *segment;
CpmlPrimitive primitive, line, curve;
CpmlPrimitive *backup;
/* Work on a copy to avoid modifying the original cairo path */
cpml_segment_from_cairo(&original, (cairo_path_t *) adg_test_path());
segment = cpml_segment_deep_dup(&original);
cpml_primitive_from_segment(&primitive, segment);
/* Offsetting and de-offsetting can introduce rounding errors
* so we use adg_assert_isapprox instead of g_assert_cmpfloat */
/* Line */
cpml_primitive_copy(&line, &primitive);
cpml_primitive_offset(&primitive, 1);
adg_assert_isapprox((primitive.org)->point.x, 0);
adg_assert_isapprox((primitive.org)->point.y, 2);
adg_assert_isapprox(primitive.data[1].point.x, 3);
adg_assert_isapprox(primitive.data[1].point.y, 2);
cpml_primitive_offset(&primitive, -1);
adg_assert_isapprox((primitive.org)->point.x, 0);
adg_assert_isapprox((primitive.org)->point.y, 1);
adg_assert_isapprox(primitive.data[1].point.x, 3);
adg_assert_isapprox(primitive.data[1].point.y, 1);
/* Arc */
cpml_primitive_next(&primitive);
cpml_primitive_offset(&primitive, 1);
adg_assert_isapprox((primitive.org)->point.x, 2.003);
adg_assert_isapprox((primitive.org)->point.y, 0.923);
adg_assert_isapprox(primitive.data[1].point.x, 3.156);
adg_assert_isapprox(primitive.data[1].point.y, 5.537);
adg_assert_isapprox(primitive.data[2].point.x, 5.463);
adg_assert_isapprox(primitive.data[2].point.y, 7.844);
cpml_primitive_offset(&primitive, -1);
adg_assert_isapprox((primitive.org)->point.x, 3);
adg_assert_isapprox((primitive.org)->point.y, 1);
adg_assert_isapprox(primitive.data[1].point.x, 4);
adg_assert_isapprox(primitive.data[1].point.y, 5);
adg_assert_isapprox(primitive.data[2].point.x, 6);
adg_assert_isapprox(primitive.data[2].point.y, 7);
/* Curve */
cpml_primitive_next(&primitive);
cpml_primitive_copy(&curve, &primitive);
/* The offset algorithm for curves is an approximation, so
* offsetting +1 and -1 does not return the original curve.
* Keeping a backup around to restore the original data.
*/
backup = cpml_primitive_deep_dup(&curve);
/* Testing different algorithms */
cpml_curve_offset_algorithm(CPML_CURVE_OFFSET_ALGORITHM_GEOMETRICAL);
cpml_primitive_offset(&primitive, 1);
adg_assert_isapprox((primitive.org)->point.x, 5.293);
adg_assert_isapprox((primitive.org)->point.y, 7.707);
adg_assert_isapprox(primitive.data[1].point.x, 7.889);
adg_assert_isapprox(primitive.data[1].point.y, 8.515);
adg_assert_isapprox(primitive.data[2].point.x, 11.196);
adg_assert_isapprox(primitive.data[2].point.y, 9.007);
adg_assert_isapprox(primitive.data[3].point.x, -1.4);
adg_assert_isapprox(primitive.data[3].point.y, 1.2);
cpml_primitive_copy_data(&primitive, backup);
cpml_curve_offset_algorithm(CPML_CURVE_OFFSET_ALGORITHM_BAIOCA);
cpml_primitive_offset(&primitive, 1);
adg_assert_isapprox((primitive.org)->point.x, 5.293);
adg_assert_isapprox((primitive.org)->point.y, 7.707);
adg_assert_isapprox(primitive.data[1].point.x, 6.901);
adg_assert_isapprox(primitive.data[1].point.y, 9.315);
adg_assert_isapprox(primitive.data[2].point.x, 10.806);
adg_assert_isapprox(primitive.data[2].point.y, 10.355);
adg_assert_isapprox(primitive.data[3].point.x, -1.4);
adg_assert_isapprox(primitive.data[3].point.y, 1.2);
cpml_primitive_copy_data(&primitive, backup);
cpml_curve_offset_algorithm(CPML_CURVE_OFFSET_ALGORITHM_HANDCRAFT);
cpml_primitive_offset(&primitive, 1);
adg_assert_isapprox((primitive.org)->point.x, 5.293);
adg_assert_isapprox((primitive.org)->point.y, 7.707);
adg_assert_isapprox(primitive.data[1].point.x, -5.758);
adg_assert_isapprox(primitive.data[1].point.y, -3.344);
adg_assert_isapprox(primitive.data[2].point.x, 24.987);
adg_assert_isapprox(primitive.data[2].point.y, 20.99);
adg_assert_isapprox(primitive.data[3].point.x, -1.4);
adg_assert_isapprox(primitive.data[3].point.y, 1.2);
cpml_primitive_copy_data(&primitive, backup);
g_free(backup);
cpml_curve_offset_algorithm(CPML_CURVE_OFFSET_ALGORITHM_DEFAULT);
/* Close: this primitive does not own data points but should
* modify the points of the previous and next primitives */
cpml_primitive_next(&primitive);
cpml_primitive_offset(&primitive, 1);
adg_assert_isapprox((curve.org)->point.x, 6);
adg_assert_isapprox((curve.org)->point.y, 7);
adg_assert_isapprox(curve.data[3].point.x, -1.553);
adg_assert_isapprox(curve.data[3].point.y, 2.894);
adg_assert_isapprox((line.org)->point.x, 0.447);
adg_assert_isapprox((line.org)->point.y, 1.894);
adg_assert_isapprox(line.data[1].point.x, 3);
adg_assert_isapprox(line.data[1].point.y, 1);
cpml_primitive_offset(&primitive, -1);
adg_assert_isapprox((curve.org)->point.x, 6);
adg_assert_isapprox((curve.org)->point.y, 7);
adg_assert_isapprox(curve.data[3].point.x, -2);
adg_assert_isapprox(curve.data[3].point.y, 2);
adg_assert_isapprox((line.org)->point.x, 0);
adg_assert_isapprox((line.org)->point.y, 1);
adg_assert_isapprox(line.data[1].point.x, 3);
adg_assert_isapprox(line.data[1].point.y, 1);
g_free(segment);
}
