1 /* CPML - Cairo Path Manipulation Library
2 * Copyright (C) 2007,2008,2009,2010,2011,2012,2013 Nicola Fontana <ntd at entidi.it>
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17 * Boston, MA 02110-1301, USA.
22 * SECTION:cpml-primitive
23 * @Section_Id:CpmlPrimitive
24 * @title: CpmlPrimitive
25 * @short_description: Basic component of segments
27 * A primitive is an atomic geometric element found inside #CpmlSegment.
28 * The available primitives are the same defined by #cairo_path_data_type_t
29 * with the additional #CPML_ARC type (check #CpmlPrimitiveType
30 * for further information) and without #CPML_MOVE as it is not
31 * considered a primitive and it is managed in different way: the move-to
32 * primitives are only used to define the origin of a segment.
39 * @CPML_MOVE: equivalent to %CAIRO_PATH_MOVE_TO
40 * @CPML_LINE: equivalent to %CAIRO_PATH_LINE_TO
41 * @CPML_CURVE: equivalent to %CAIRO_PATH_CURVE_TO
42 * @CPML_CLOSE: equivalent to %CAIRO_PATH_CLOSE_PATH
43 * @CPML_ARC: an arc representation at CPML level
45 * This is a type compatible with #cairo_path_data_type_t type. It is
46 * basically the same enum but it embodies an important difference:
47 * it can be used to specify the special #CPML_ARC primitive. Having
48 * two different types is a good way to make clear when a function
49 * expect or not embedded #CPML_ARC primitives.
51 * Arcs are used extensively in technical drawing: some operations are
52 * trivials with arcs and a nightmare with cubic Bézier curves. Actually,
53 * at least up to version 1.10.2, the cairo library does not support arc
54 * primitives natively and there is no plan they will be ever supported.
56 * The CPML library supports arc natively, converting them to curves
57 * when the #CpmlSegment is returned to the cairo context, for instance
58 * when using cpml_segment_to_cairo().
65 * @segment: the source #CpmlSegment
66 * @org: a pointer to the first point of the primitive
67 * @data: the array of the path data, prepended by the header
69 * As for #CpmlSegment, also the primitive is unobtrusive. This
70 * means CpmlPrimitive does not include any coordinates but instead
71 * keeps pointers to the original segment (and, by transition, to
72 * the underlying #CpmlPath struct).
78 #include "cpml-internal.h"
79 #include "cpml-extents.h"
80 #include "cpml-segment.h"
81 #include "cpml-primitive.h"
82 #include "cpml-primitive-private.h"
84 #include "cpml-curve.h"
89 static const _CpmlPrimitiveClass
*
90 _cpml_class_from_type (CpmlPrimitiveType type
);
91 static const _CpmlPrimitiveClass
*
92 _cpml_class_from_obj (const CpmlPrimitive
*primitive
);
93 static cairo_path_data_t
*
94 _cpml_get_point (const CpmlPrimitive
*primitive
,
96 static void _cpml_dump_point (const cairo_path_data_t
*path_data
);
100 * cpml_primitive_type_get_n_points:
101 * @type: a primitive type
103 * Gets the number of points required to identify the @type primitive.
105 * Returns: the number of points or %0 on errors
110 cpml_primitive_type_get_n_points(CpmlPrimitiveType type
)
112 const _CpmlPrimitiveClass
*class_data
= _cpml_class_from_type(type
);
114 if (class_data
== NULL
)
117 return class_data
->n_points
;
121 * cpml_primitive_from_segment:
122 * @primitive: the destination #CpmlPrimitive struct
123 * @segment: (allow-none): the source segment
125 * Initializes @primitive to the first primitive of @segment.
130 cpml_primitive_from_segment(CpmlPrimitive
*primitive
, CpmlSegment
*segment
)
132 primitive
->segment
= segment
;
134 if (segment
!= NULL
) {
135 /* The first element of a CpmlSegment is always a CPML_MOVE,
136 * as ensured by cpml_segment_from_cairo() and by the browsing APIs,
137 * so the origin is in the second data item */
138 primitive
->org
= segment
->data
+ 1;
140 /* Also, the segment APIs ensure that @segment is prepended by
141 * only one CPML_MOVE */
142 primitive
->data
= segment
->data
+ segment
->data
->header
.length
;
144 primitive
->org
= NULL
;
145 primitive
->data
= NULL
;
150 * cpml_primitive_copy:
151 * @primitive: the destination #CpmlPrimitive
152 * @src: (allow-none): the source #CpmlPrimitive
154 * Copies @src in @primitive. This is a shallow copy: the internal fields
155 * of @primitive refer to the same memory as the original @src primitive.
160 cpml_primitive_copy(CpmlPrimitive
*primitive
, const CpmlPrimitive
*src
)
163 memcpy(primitive
, src
, sizeof(CpmlPrimitive
));
168 * cpml_primitive_reset:
169 * @primitive: a #CpmlPrimitive
171 * Resets @primitive so it refers to the first primitive of the
177 cpml_primitive_reset(CpmlPrimitive
*primitive
)
179 cpml_primitive_from_segment(primitive
, primitive
->segment
);
183 * cpml_primitive_next:
184 * @primitive: a #CpmlPrimitive
186 * Changes @primitive so it refers to the next primitive on the
187 * source segment. If there are no more primitives, @primitive is
188 * not changed and 0 is returned.
190 * Returns: (type boolean): %1 on success, %0 if no next primitive found or errors.
195 cpml_primitive_next(CpmlPrimitive
*primitive
)
197 cairo_path_data_t
*new_data
;
198 const cairo_path_data_t
*end_data
;
200 new_data
= primitive
->data
+ primitive
->data
->header
.length
;
201 end_data
= primitive
->segment
->data
+ primitive
->segment
->num_data
;
203 if (new_data
>= end_data
)
206 primitive
->org
= _cpml_get_point(primitive
, -1);
207 primitive
->data
= new_data
;
213 * cpml_primitive_get_n_points:
214 * @primitive: a #CpmlPrimitive
216 * Gets the number of points required to identify @primitive.
217 * It is similar to cpml_primitive_type_get_n_points() but using
218 * a @primitive instance instead of a type.
220 * Returns: the number of points or %0 on errors.
222 * <!-- Virtual: n_points -->
227 cpml_primitive_get_n_points(const CpmlPrimitive
*primitive
)
229 return cpml_primitive_type_get_n_points(primitive
->data
->header
.type
);
233 * cpml_primitive_get_length:
234 * @primitive: a #CpmlPrimitive
236 * Abstracts the length() family functions by providing a common
237 * way to access the underlying primitive-specific implementation.
238 * The function returns the length of @primitive.
240 * Returns: the requested length or 0 on errors
242 * <!-- Virtual: get_length -->
247 cpml_primitive_get_length(const CpmlPrimitive
*primitive
)
249 const _CpmlPrimitiveClass
*class_data
= _cpml_class_from_obj(primitive
);
251 if (class_data
== NULL
|| class_data
->get_length
== NULL
)
254 return class_data
->get_length(primitive
);
258 * cpml_primitive_put_extents:
259 * @primitive: a #CpmlPrimitive
260 * @extents: (out caller-allocates): where to store the extents
262 * Abstracts the extents() family functions by providing a common
263 * way to access the underlying primitive-specific implementation.
265 * This function stores in @extents the bounding box of @primitive.
267 * On errors, that is if the extents cannot be calculated for some
268 * reason, this function does nothing.
270 * <!-- Virtual: put_extents -->
275 cpml_primitive_put_extents(const CpmlPrimitive
*primitive
,
276 CpmlExtents
*extents
)
278 const _CpmlPrimitiveClass
*class_data
= _cpml_class_from_obj(primitive
);
280 if (class_data
== NULL
|| class_data
->put_extents
== NULL
)
283 class_data
->put_extents(primitive
, extents
);
287 * cpml_primitive_set_point:
288 * @primitive: a #CpmlPrimitive
289 * @n_point: the index of the point to retrieve
290 * @pair: (allow-none): the source #CpmlPair
292 * Sets the specified @n_point of @primitive to @pair. The @n_point
293 * index starts from 0: if @n_point is 0, the start point (the origin)
294 * is changed, 1 for the second point and so on. If @n_point is
295 * negative, it is considered as a negative index from the end, so
296 * that -1 is the end point, -2 the point before the end point and
299 * #CPML_CLOSE is managed in a special way: if @n_point
300 * is -1 or 1 and @primitive is a close-path, this function cycles
301 * the source #CpmlSegment and returns the first point. This is
302 * needed because requesting the end point (or the second point)
303 * of a close path is a valid operation and must returns the origin
309 cpml_primitive_set_point(CpmlPrimitive
*primitive
,
310 int n_point
, const CpmlPair
*pair
)
312 cairo_path_data_t
*point
= _cpml_get_point(primitive
, n_point
);
314 if (point
!= NULL
&& pair
!= NULL
)
315 cpml_pair_to_cairo(pair
, point
);
319 * cpml_primitive_put_point:
320 * @primitive: a #CpmlPrimitive
321 * @n_point: the index of the point to retrieve
322 * @pair: (out caller-allocates): the destination #CpmlPair
324 * Gets the specified @n_point from @primitive and stores it into
325 * @pair. The @n_point index is subject to the same rules explained
326 * in the cpml_primitive_set_point() function.
331 cpml_primitive_put_point(const CpmlPrimitive
*primitive
,
332 int n_point
, CpmlPair
*pair
)
334 const cairo_path_data_t
*point
= _cpml_get_point(primitive
, n_point
);
337 cpml_pair_from_cairo(pair
, point
);
341 * cpml_primitive_put_pair_at:
342 * @primitive: a #CpmlPrimitive
343 * @pos: the position value
344 * @pair: (out caller-allocates): the destination #CpmlPair
346 * Abstracts the put_pair_at() family functions by providing a common
347 * way to access the underlying primitive-specific implementation.
349 * It gets the coordinates of the point lying on @primitive
350 * at position @pos. @pos is an homogeneous factor where 0 is the
351 * start point, 1 the end point, 0.5 the mid point and so on.
352 * @pos can be less than 0 or greater than %1, in which case the
353 * coordinates of @pair are interpolated.
355 * On errors, that is if the coordinates cannot be calculated for
356 * some reason, this function does nothing.
358 * <!-- Virtual: put_pair_at -->
363 cpml_primitive_put_pair_at(const CpmlPrimitive
*primitive
,
364 double pos
, CpmlPair
*pair
)
366 const _CpmlPrimitiveClass
*class_data
= _cpml_class_from_obj(primitive
);
368 if (class_data
== NULL
|| class_data
->put_pair_at
== NULL
)
371 class_data
->put_pair_at(primitive
, pos
, pair
);
375 * cpml_primitive_put_vector_at:
376 * @primitive: a #CpmlPrimitive
377 * @pos: the position value
378 * @vector: (out caller-allocates): the destination #CpmlVector
380 * Abstracts the put_vector_at() family functions by providing a common
381 * way to access the underlying primitive-specific implementation.
383 * It gets the steepness of the point at position @pos on @primitive.
384 * @pos is an homogeneous factor where 0 is the start point, 1 the
385 * end point, 0.5 the mid point and so on.
386 * @pos can be less than 0 or greater than %1, in which case the
387 * coordinates of @pair are interpolated.
389 * On errors, that is if the steepness cannot be calculated for
390 * some reason, this function does nothing.
392 * <!-- Virtual: put_vector_at -->
397 cpml_primitive_put_vector_at(const CpmlPrimitive
*primitive
,
398 double pos
, CpmlVector
*vector
)
400 const _CpmlPrimitiveClass
*class_data
= _cpml_class_from_obj(primitive
);
402 if (class_data
== NULL
|| class_data
->put_vector_at
== NULL
)
405 class_data
->put_vector_at(primitive
, pos
, vector
);
409 * cpml_primitive_get_closest_pos:
410 * @primitive: a #CpmlPrimitive
411 * @pair: (allow-none): the coordinates of the subject point
413 * Returns the pos value of the point on @primitive nearest to @pair.
414 * The returned value is always clamped between %0 and %1.
416 * Returns: the requested pos value between %0 and %1, or %-1 on errors.
418 * <!-- Virtual: get_closest_pos -->
423 cpml_primitive_get_closest_pos(const CpmlPrimitive
*primitive
,
424 const CpmlPair
*pair
)
426 const _CpmlPrimitiveClass
*class_data
;
431 class_data
= _cpml_class_from_obj(primitive
);
432 if (class_data
== NULL
|| class_data
->get_closest_pos
== NULL
)
435 return class_data
->get_closest_pos(primitive
, pair
);
439 * cpml_primitive_put_intersections:
440 * @primitive: the first #CpmlPrimitive
441 * @primitive2: (allow-none) the second #CpmlPrimitive
442 * @n_dest: maximum number of intersections to return
443 * @dest: (out caller-allocates) (array length=n_dest) (allow-none): the destination buffer that can contain @n_dest #CpmlPair
445 * Finds the intersection points between the given primitives and
446 * returns the result in @dest. The size of @dest should be enough
447 * to store @n_dest #CpmlPair. The maximum number of intersections
448 * is dependent on the type of the primitive involved in the
449 * operation. If there are at least one Bézier curve involved, up to
450 * %4 intersections could be returned. Otherwise, if there is an arc
451 * the intersections will be %2 at maximum. For line primitives, there
452 * is only %1 point (or %0 if the lines are parallel).
456 * The convention used by the CPML library is that a primitive should
457 * implement only the intersection algorithms with lower degree
458 * primitives. This is required to avoid code duplication: intersection
459 * between arc and Bézier curves must be implemented by #CPML_CURVE and
460 * intersection between lines and arcs must be implemented by #CPML_ARC.
461 * cpml_primitive_put_intersections() will take care of swapping the
462 * arguments if they are not properly ordered.
466 * Returns: the number of intersection points found or 0 if the
467 * primitives do not intersect or on errors.
469 * <!-- Virtual: put_intersections -->
474 cpml_primitive_put_intersections(const CpmlPrimitive
*primitive
,
475 const CpmlPrimitive
*primitive2
,
476 size_t n_dest
, CpmlPair
*dest
)
478 const _CpmlPrimitiveClass
*class_data
;
479 size_t n_points
, n_points2
;
481 if (primitive2
== NULL
|| dest
== NULL
)
484 class_data
= _cpml_class_from_obj(primitive
);
485 if (class_data
== NULL
|| class_data
->put_intersections
== NULL
)
488 n_points
= cpml_primitive_get_n_points(primitive
);
489 n_points2
= cpml_primitive_get_n_points(primitive2
);
491 if (n_points
== 0 || n_points2
== 0)
494 /* Primitives reordering: the first must be the more complex one */
495 if (n_points
< n_points2
) {
496 const CpmlPrimitive
*old_primitive2
= primitive2
;
497 primitive2
= primitive
;
498 primitive
= old_primitive2
;
501 return class_data
->put_intersections(primitive
, primitive2
, n_dest
, dest
);
505 * cpml_primitive_put_intersections_with_segment:
506 * @primitive: a #CpmlPrimitive
507 * @segment: (allow-none): a #CpmlSegment
508 * @n_dest: maximum number of intersections to return
509 * @dest: (out caller-allocates) (array length=n_dest) (allow-none): the destination buffer that can contain @n_dest #CpmlPair
511 * Computes the intersections between @segment and @primitive by
512 * sequentially scanning the primitives in @segment and looking
513 * for their intersections with @primitive.
515 * If the intersections are more than @n_dest, only the first
516 * @n_dest pairs are stored.
518 * Returns: the number of intersection points found or 0 if the
519 * items do not intersect or on errors.
524 cpml_primitive_put_intersections_with_segment(const CpmlPrimitive
*primitive
,
525 const CpmlSegment
*segment
,
526 size_t n_dest
, CpmlPair
*dest
)
528 CpmlPrimitive portion
;
531 if (segment
== NULL
|| dest
== NULL
)
534 cpml_primitive_from_segment(&portion
, (CpmlSegment
*) segment
);
537 while (found
< n_dest
) {
538 found
+= cpml_primitive_put_intersections(&portion
, primitive
,
539 n_dest
-found
, dest
+found
);
540 if (!cpml_primitive_next(&portion
))
548 * cpml_primitive_offset:
549 * @primitive: a #CpmlPrimitive
550 * @offset: distance for the computed offset primitive
552 * Given a primitive, computes the same (or approximated) parallel
553 * primitive distant @offset from the original one and returns
554 * the result by changing @primitive.
556 * On errors, that is if the offset primitive cannot be calculated
557 * for some reason, this function does nothing.
559 * <!-- Virtual: offset -->
564 cpml_primitive_offset(CpmlPrimitive
*primitive
, double offset
)
566 const _CpmlPrimitiveClass
*class_data
= _cpml_class_from_obj(primitive
);
568 if (class_data
== NULL
|| class_data
->offset
== NULL
)
571 class_data
->offset(primitive
, offset
);
575 * cpml_primitive_join:
576 * @primitive: the first #CpmlPrimitive
577 * @primitive2: (inout) (transfer none): the second #CpmlPrimitive
579 * Joins two primitive modifying the end point of @primitive and the
580 * start point of @primitive2 so that the resulting points will overlap.
583 * <title>TODO</title>
585 * <listitem>Actually, the join is done by extending the end vector
586 * of @primitive and the start vector of @primitive2 and
587 * interpolating the intersection: this means no primitive
588 * dependent code is needed. Anyway, it is likely to change
589 * in the future because this approach is quite naive when
590 * curves are involved.</listitem>
594 * Returns: (type boolean): %1 on success, %0 if the primitives cannot be joint.
596 * <!-- Virtual: join -->
601 cpml_primitive_join(CpmlPrimitive
*primitive
, CpmlPrimitive
*primitive2
)
603 cairo_path_data_t
*end1
, *start2
;
604 CpmlPrimitive line1
, line2
;
605 cairo_path_data_t data1
[2], data2
[2];
608 end1
= _cpml_get_point(primitive
, -1);
609 start2
= _cpml_get_point(primitive2
, 0);
611 /* Check if the primitives are yet connected */
612 if (end1
->point
.x
== start2
->point
.x
&& end1
->point
.y
== start2
->point
.y
)
615 line1
.org
= _cpml_get_point(primitive
, -2);
617 data1
[0].header
.type
= CPML_LINE
;
622 data2
[0].header
.type
= CPML_LINE
;
623 data2
[1] = *_cpml_get_point(primitive2
, 1);
625 if (!cpml_primitive_put_intersections(&line1
, &line2
, 1, &joint
))
628 cpml_pair_to_cairo(&joint
, end1
);
629 cpml_pair_to_cairo(&joint
, start2
);
635 * cpml_primitive_to_cairo:
636 * @primitive: a #CpmlPrimitive
637 * @cr: (inout) (transfer none): the destination cairo context
639 * Renders a single @primitive to the @cr cairo context.
640 * As a special case, if the primitive is a #CPML_CLOSE, an
641 * equivalent line is rendered, because a close path left alone
644 * Also a #CPML_ARC primitive is treated specially, as it is not
645 * natively supported by cairo and has its own rendering API.
650 cpml_primitive_to_cairo(const CpmlPrimitive
*primitive
, cairo_t
*cr
)
652 CpmlPrimitiveType type
;
654 cairo_path_data_t
*path_data
;
656 cairo_move_to(cr
, primitive
->org
->point
.x
, primitive
->org
->point
.y
);
658 type
= primitive
->data
->header
.type
;
660 if (type
== CPML_CLOSE
) {
661 path_data
= _cpml_get_point(primitive
, -1);
662 cairo_line_to(cr
, path_data
->point
.x
, path_data
->point
.y
);
663 } else if (type
== CPML_ARC
) {
664 cpml_arc_to_cairo(primitive
, cr
);
666 path
.status
= CAIRO_STATUS_SUCCESS
;
667 path
.data
= primitive
->data
;
668 path
.num_data
= primitive
->data
->header
.length
;
669 cairo_append_path(cr
, &path
);
674 * cpml_primitive_dump:
675 * @primitive: a #CpmlPrimitive
676 * @org_also: whether to output also the origin coordinates
678 * Dumps info on the specified @primitive to stdout: useful for
679 * debugging purposes. If @org_also is 1, a #CPML_MOVE to the
680 * origin is prepended to the data otherwise the
681 * <structfield>org</structfield> field is not used.
686 cpml_primitive_dump(const CpmlPrimitive
*primitive
, int org_also
)
688 const cairo_path_data_t
*data
;
690 const _CpmlPrimitiveClass
*class_data
;
693 data
= primitive
->data
;
694 type
= data
->header
.type
;
695 class_data
= _cpml_class_from_type(type
);
697 if (class_data
== NULL
) {
698 printf("Unknown primitive type (%d)\n", type
);
702 /* Dump the origin, if requested */
705 _cpml_dump_point(primitive
->org
);
709 printf("%s ", class_data
->name
);
711 n_points
= cpml_primitive_get_n_points(primitive
);
712 for (n
= 1; n
< n_points
; ++n
)
713 _cpml_dump_point(_cpml_get_point(primitive
, n
));
719 static const _CpmlPrimitiveClass
*
720 _cpml_class_from_type(CpmlPrimitiveType type
)
722 if (type
== CPML_LINE
)
723 return _cpml_line_get_class();
724 else if (type
== CPML_ARC
)
725 return _cpml_arc_get_class();
726 else if (type
== CPML_CURVE
)
727 return _cpml_curve_get_class();
728 else if (type
== CPML_CLOSE
)
729 return _cpml_close_get_class();
734 static const _CpmlPrimitiveClass
*
735 _cpml_class_from_obj(const CpmlPrimitive
*primitive
)
737 return _cpml_class_from_type(primitive
->data
->header
.type
);
742 * @primitive: a #CpmlPrimitive
743 * @n_point: the index of the point to retrieve
745 * Gets the specified @n_point from @primitive. The index starts
746 * at 0: if @n_point is 0, the start point (the origin) is
747 * returned, 1 for the second point and so on. If @n_point is
748 * negative, it is considered as a negative index from the end,
749 * so that -1 is the end point, -2 the point before the end point
752 * #CPML_CLOSE is managed in a special way: if @n_point
753 * is -1 or 1 and @primitive is a close-path, this function cycles
754 * the source #CpmlSegment and returns the first point. This is
755 * needed because requesting the end point (or the second point)
756 * of a close path is a valid operation and must returns the start
759 * Returns: a pointer to the requested point (in cairo format)
760 * or %NULL if the point is outside the valid range
764 static cairo_path_data_t
*
765 _cpml_get_point(const CpmlPrimitive
*primitive
, int n_point
)
769 /* For a start point request, simply return the origin
770 * without further checking */
772 return primitive
->org
;
774 /* The CPML_CLOSE special case */
775 if (primitive
->data
->header
.type
== CAIRO_PATH_CLOSE_PATH
&&
776 (n_point
== 1 || n_point
== -1))
777 return &primitive
->segment
->data
[1];
779 n_points
= cpml_primitive_get_n_points(primitive
);
783 /* If n_point is negative, consider it as a negative index from the end */
785 n_point
= n_points
+ n_point
;
787 /* Out of range condition */
788 if (n_point
< 0 || n_point
>= n_points
)
791 return n_point
== 0 ? primitive
->org
: &primitive
->data
[n_point
];
795 _cpml_dump_point(const cairo_path_data_t
*path_data
)
797 printf("(%g %g) ", path_data
->point
.x
, path_data
->point
.y
);