cpml/cpml-segment.c

   1 /* CPML - Cairo Path Manipulation Library
   2  * Copyright (C) 2008, 2009  Nicola Fontana <ntd at entidi.it>
   3  *
   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.
   8  *
   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.
  13  *
  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.
  18  */
  19
  20 /**
  21  * SECTION:segment
  22  * @title: CpmlSegment
  23  * @short_description: Contiguous lines
  24  *
  25  * A segment is a single contiguous line got from a cairo path.
  26  *
  27  * Every #cairo_path_t struct can contain more than one segment:
  28  * the CPML library provides iteration APIs to browse these segments.
  29  * The CpmlSegment struct internally keeps a reference to the source
  30  * cairo path so it can be used both for getting segment data and
  31  * browsing the segments (that is, it is used also as an iterator).
  32  *
  33  * Use cpml_segment_reset() to reset the iterator at the start of the cairo
  34  * path (at the first segment) and cpml_segment_next() to get the next
  35  * segment. Getting the previous segment is not provided, as the underlying
  36  * struct is not accessible in reverse order.
  37  **/
  38
  39 /**
  40  * CpmlSegment:
  41  * @source: the source #cairo_path_t struct
  42  * @data: the segment data
  43  * @num_data: size of @data
  44  *
  45  * This is an unobtrusive struct to identify a segment inside a
  46  * cairo path. Unobtrusive means that the real coordinates are
  47  * still stored in @source: CpmlSegment only provides a way to
  48  * access the underlying cairo path.
  49  **/
  50
  51 #include "cpml-segment.h"
  52 #include "cpml-primitive.h"
  53 #include "cpml-line.h"
  54 #include "cpml-curve.h"
  55 #include "cpml-pair.h"
  56 #include "cpml-alloca.h"
  57
  58 #include <stdio.h>
  59 #include <string.h>
  60
  61 static cairo_bool_t     segment_normalize       (CpmlSegment       *segment);
  62 static void             join_primitives         (cairo_path_data_t *last_data,
  63                                                  const CpmlVector  *last_vector,
  64                                                  const CpmlPair    *new_point,
  65                                                  const CpmlVector  *new_vector);
  66
  67
  68 /**
  69  * cpml_segment_from_cairo:
  70  * @segment: a #CpmlSegment
  71  * @cairo_path: the source cairo_path_t
  72  *
  73  * Builds a CpmlSegment from a cairo_path_t structure. This operation
  74  * involves stripping the leading %CAIRO_PATH_MOVE_TO primitives and
  75  * setting the internal segment structure accordling. A pointer to the
  76  * source cairo path is kept.
  77  *
  78  * This function will fail if @cairo_path is null, empty or if its
  79  * %status member is not %CAIRO_STATUS_SUCCESS. Also, the first
  80  * primitive must be a CAIRO_PATH_MOVE_TO, so no dependency on the
  81  * cairo context is needed.
  82  *
  83  * Return value: 1 on success, 0 on errors
  84  **/
  85 cairo_bool_t
  86 cpml_segment_from_cairo(CpmlSegment *segment, cairo_path_t *cairo_path)
  87 {
  88     /* The cairo path should be defined and in perfect state */
  89     if (cairo_path == NULL || cairo_path->num_data == 0 ||
  90         cairo_path->status != CAIRO_STATUS_SUCCESS)
  91         return 0;
  92
  93     segment->source = cairo_path;
  94     segment->data = cairo_path->data;
  95     segment->num_data = cairo_path->num_data;
  96
  97     return segment_normalize(segment);
  98 }
  99
 100 /**
 101  * cpml_segment_copy:
 102  * @segment: a #CpmlSegment
 103  * @src: the source segment to copy
 104  *
 105  * Makes a shallow copy of @src into @segment.
 106  *
 107  * Return value: @segment or %NULL on errors
 108  **/
 109 CpmlSegment *
 110 cpml_segment_copy(CpmlSegment *segment, const CpmlSegment *src)
 111 {
 112     if (segment == NULL || src == NULL)
 113         return NULL;
 114
 115     return memcpy(segment, src, sizeof(CpmlSegment));
 116 }
 117
 118 /**
 119  * cpml_segment_dump:
 120  * @segment: a #CpmlSegment
 121  *
 122  * Dumps the specified @segment to stdout. Useful for debugging purposes.
 123  **/
 124 void
 125 cpml_segment_dump(const CpmlSegment *segment)
 126 {
 127     cairo_path_data_t *data;
 128     int n, n_point;
 129
 130     for (n = 0; n < segment->num_data; ++n) {
 131         data = segment->data + n;
 132
 133         switch (data->header.type) {
 134         case CAIRO_PATH_MOVE_TO:
 135             printf("Move to ");
 136             break;
 137         case CAIRO_PATH_LINE_TO:
 138             printf("Line to ");
 139             break;
 140         case CAIRO_PATH_CURVE_TO:
 141             printf("Curve to ");
 142             break;
 143         case CAIRO_PATH_CLOSE_PATH:
 144             printf("Path close");
 145             break;
 146         default:
 147             printf("Unknown entity (%d)", data->header.type);
 148             break;
 149         }
 150
 151         for (n_point = 1; n_point < data->header.length; ++n_point)
 152             printf("(%lf, %lf) ", data[n_point].point.x,
 153                    data[n_point].point.y);
 154
 155         n += n_point - 1;
 156         printf("\n");
 157     }
 158 }
 159
 160 /**
 161  * cpml_segment_reset:
 162  * @segment: a #CpmlSegment
 163  *
 164  * Modifies @segment to point to the first segment of the source path.
 165  **/
 166 void
 167 cpml_segment_reset(CpmlSegment *segment)
 168 {
 169     segment->data = segment->source->data;
 170     segment->num_data = segment->source->num_data;
 171     segment_normalize(segment);
 172 }
 173
 174 /**
 175  * cpml_segment_next:
 176  * @segment: a #CpmlSegment
 177  *
 178  * Modifies @segment to point to the next segment of the source path.
 179  *
 180  * Return value: 1 on success, 0 if no next segment found or errors
 181  **/
 182 cairo_bool_t
 183 cpml_segment_next(CpmlSegment *segment)
 184 {
 185     int rest = segment->source->num_data - segment->num_data +
 186         segment->source->data - segment->data;
 187
 188     if (rest <= 0)
 189         return 0;
 190
 191     segment->data += segment->num_data;
 192     segment->num_data = rest;
 193
 194     return segment_normalize(segment);
 195 }
 196
 197 /**
 198  * cpml_segment_reverse:
 199  * @segment: a #CpmlSegment
 200  *
 201  * Reverses @segment in-place. The resulting rendering will be the same,
 202  * but with the primitives generated in reverse order.
 203  **/
 204 void
 205 cpml_segment_reverse(CpmlSegment *segment)
 206 {
 207     cairo_path_data_t *data, *dst_data;
 208     size_t data_size;
 209     double end_x, end_y;
 210     int n, num_points, n_point;
 211     const cairo_path_data_t *src_data;
 212
 213     data_size = sizeof(cairo_path_data_t) * segment->num_data;
 214     data = cpml_alloca(data_size);
 215     end_x = segment->data[1].point.x;
 216     end_y = segment->data[1].point.y;
 217
 218     for (n = 2; n < segment->num_data; ++n) {
 219         src_data = segment->data + n;
 220         num_points = src_data->header.length;
 221
 222         dst_data = data + segment->num_data - n - num_points + 2;
 223         dst_data->header.type = src_data->header.type;
 224         dst_data->header.length = num_points;
 225
 226         for (n_point = 1; n_point < num_points; ++n_point) {
 227             dst_data[num_points - n_point].point.x = end_x;
 228             dst_data[num_points - n_point].point.y = end_y;
 229             end_x = src_data[n_point].point.x;
 230             end_y = src_data[n_point].point.y;
 231         }
 232
 233         n += n_point - 1;
 234     }
 235
 236     data[0].header.type = CAIRO_PATH_MOVE_TO;
 237     data[0].header.length = 2;
 238     data[1].point.x = end_x;
 239     data[1].point.y = end_y;
 240     memcpy(segment->data, data, data_size);
 241 }
 242
 243 /**
 244  * cpml_segment_transform:
 245  * @segment: a #CpmlSegment
 246  * @matrix: the matrix to be applied
 247  *
 248  * Applies @matrix on all the points of @segment.
 249  **/
 250 void
 251 cpml_segment_transform(CpmlSegment *segment, const cairo_matrix_t *matrix)
 252 {
 253     cairo_path_data_t *data;
 254     int n, n_point, num_points;
 255
 256     data = segment->data;
 257
 258     for (n = 0; n < segment->num_data; n += num_points) {
 259         num_points = data->header.length;
 260         ++data;
 261         for (n_point = 1; n_point < num_points; ++n_point) {
 262             cairo_matrix_transform_point(matrix, &data->point.x, &data->point.y);
 263             ++data;
 264         }
 265     }
 266 }
 267
 268 /**
 269  * cpml_segment_offset:
 270  * @segment: a #CpmlSegment
 271  * @offset: the offset distance
 272  *
 273  * Offsets a segment of the specified amount, that is builds a "parallel"
 274  * segment at the @offset distance from the original one and returns the
 275  * result by replacing the original @segment.
 276  *
 277  * Return value: 1 on success, 0 on errors
 278  *
 279  * @todo: closed path are not yet managed; the solution is not so obvious.
 280  **/
 281 cairo_bool_t
 282 cpml_segment_offset(CpmlSegment *segment, double offset)
 283 {
 284     int n, num_points, n_point;
 285     cairo_path_data_t *data;
 286     cairo_path_data_t *last_data;
 287     CpmlVector v_old, v_new;
 288     CpmlPair p_old;
 289     CpmlPair p[4];
 290
 291     last_data = NULL;
 292     p_old.x = 0;
 293     p_old.y = 0;
 294
 295     for (n = 0; n < segment->num_data; n += data->header.length) {
 296         data = segment->data + n;
 297         num_points = data->header.length - 1;
 298
 299         /* Fill the p[] vector */
 300         cpml_pair_copy(&p[0], &p_old);
 301         for (n_point = 1; n_point <= num_points; ++ n_point) {
 302             p[n_point].x = data[n_point].point.x;
 303             p[n_point].y = data[n_point].point.y;
 304         }
 305
 306         /* Save the last direction vector in v_old */
 307         cpml_pair_copy(&v_old, &v_new);
 308
 309         switch (data->header.type) {
 310
 311         case CAIRO_PATH_MOVE_TO:
 312             v_new.x = 0;
 313             v_new.y = 0;
 314             break;
 315
 316         case CAIRO_PATH_LINE_TO:
 317             {
 318                 CpmlPrimitive line;
 319                 cairo_path_data_t dummy[3];
 320
 321                 cpml_pair_to_cairo(&p[0], &dummy[0]);
 322                 dummy[1].header.type = CAIRO_PATH_LINE_TO;
 323                 dummy[1].header.length = 2;
 324                 cpml_pair_to_cairo(&p[1], &dummy[2]);
 325
 326                 line.source = NULL;
 327                 line.org = &dummy[0];
 328                 line.data = &dummy[1];
 329
 330                 cpml_line_offset(&line, offset);
 331
 332                 cpml_pair_from_cairo(&p[0], &dummy[0]);
 333                 cpml_pair_from_cairo(&p[1], &dummy[2]);
 334             }
 335             break;
 336
 337         case CAIRO_PATH_CURVE_TO:
 338             {
 339                 CpmlPrimitive curve;
 340                 cairo_path_data_t dummy[5];
 341
 342                 cpml_pair_to_cairo(&p[0], &dummy[0]);
 343                 dummy[1].header.type = CAIRO_PATH_CURVE_TO;
 344                 dummy[1].header.length = 4;
 345                 cpml_pair_to_cairo(&p[1], &dummy[2]);
 346                 cpml_pair_to_cairo(&p[2], &dummy[3]);
 347                 cpml_pair_to_cairo(&p[3], &dummy[4]);
 348
 349                 curve.source = NULL;
 350                 curve.org = &dummy[0];
 351                 curve.data = &dummy[1];
 352
 353                 cpml_curve_offset(&curve, offset);
 354
 355                 cpml_pair_from_cairo(&p[0], &dummy[0]);
 356                 cpml_pair_from_cairo(&p[1], &dummy[2]);
 357                 cpml_pair_from_cairo(&p[2], &dummy[3]);
 358                 cpml_pair_from_cairo(&p[3], &dummy[4]);
 359             }
 360             break;
 361
 362         case CAIRO_PATH_CLOSE_PATH:
 363             return 1;
 364         }
 365
 366         join_primitives(last_data, &v_old, &p[0], &v_new);
 367
 368         /* Save the end point of the original primitive in p_old */
 369         last_data = data + num_points;
 370         p_old.x = last_data->point.x;
 371         p_old.y = last_data->point.y;
 372
 373         /* Store the results got from the p[] vector in the cairo path */
 374         for (n_point = 1; n_point <= num_points; ++ n_point) {
 375             data[n_point].point.x = p[n_point].x;
 376             data[n_point].point.y = p[n_point].y;
 377         }
 378     }
 379
 380     return 1;
 381 }
 382
 383 /**
 384  * segment_normalize:
 385  * @segment: a #CpmlSegment
 386  *
 387  * Strips the leading CAIRO_PATH_MOVE_TO primitives, updating the CpmlSegment
 388  * structure accordling. One, and only once, MOVE_TO primitive is left.
 389  *
 390  * Return value: 1 on success, 0 on no leading MOVE_TOs or on errors
 391  **/
 392 static cairo_bool_t
 393 segment_normalize(CpmlSegment *segment)
 394 {
 395     cairo_path_data_t *data;
 396
 397     if (segment->source->data->header.type != CAIRO_PATH_MOVE_TO) {
 398         return 0;
 399     }
 400
 401     data = segment->data;
 402
 403     while (segment->num_data >= 0) {
 404         data += 2;
 405         if (data->header.type != CAIRO_PATH_MOVE_TO)
 406             return 1;
 407
 408         segment->data = data;
 409         segment->num_data -= 2;
 410     }
 411
 412     return 0;
 413 }
 414
 415 /**
 416  * join_primitives:
 417  * @last_data: the previous primitive end data point (if any)
 418  * @last_vector: @last_data direction vector
 419  * @new_point: the new primitive starting point
 420  * @new_vector: @new_point direction vector
 421  *
 422  * Joins two primitive modifying the end point of the first one (stored
 423  * as cairo path data in @last_data).
 424  *
 425  * @todo: this approach is quite naive when curves are involved.
 426  **/
 427 static void
 428 join_primitives(cairo_path_data_t *last_data, const CpmlVector *last_vector,
 429                 const CpmlPair *new_point, const CpmlVector *new_vector)
 430 {
 431     CpmlPair last_point;
 432
 433     if (last_data == NULL)
 434         return;
 435
 436     last_point.x = last_data->point.x;
 437     last_point.y = last_data->point.y;
 438
 439     if (cpml_pair_intersection_pv_pv(&last_point,
 440                                      &last_point, last_vector,
 441                                      new_point, new_vector)) {
 442         last_data->point.x = last_point.x;
 443         last_data->point.y = last_point.y;
 444     } else {
 445         last_data->point.x = new_point->x;
 446         last_data->point.y = new_point->y;
 447     }
 448 }