mirror of
https://gitlab.freedesktop.org/cairo/cairo.git
synced 2025-12-21 06:20:08 +01:00
stroke: Convert the outlines into contour and then into a polygon
In step 1 of speeding up stroking, we introduce contours as a means for tracking the connected edges around the stroke. By keeping track of these chains, we can analyse the edges as we proceed and eliminate redundant vertices speeding up rasterisation. Coincidentally fixes line-width-tolerance (looks like a combination of using spline tangent vectors and tolerance). Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
This commit is contained in:
Chris Wilson
parent
bbe704406c
commit
545f30856a
15 changed files with 2151 additions and 457 deletions
|
|
@ -62,6 +62,7 @@ cairo_private = \
|
|||
cairo-clip-private.h \
|
||||
cairo-combsort-private.h \
|
||||
cairo-compiler-private.h \
|
||||
cairo-contour-private.h \
|
||||
cairo-composite-rectangles-private.h \
|
||||
cairo-default-context-private.h \
|
||||
cairo-device-private.h \
|
||||
|
|
@ -132,6 +133,7 @@ cairo_sources = \
|
|||
cairo-clip-surface.c \
|
||||
cairo-color.c \
|
||||
cairo-composite-rectangles.c \
|
||||
cairo-contour.c \
|
||||
cairo-debug.c \
|
||||
cairo-default-context.c \
|
||||
cairo-device.c \
|
||||
|
|
|
|||
159
src/cairo-contour-private.h
Normal file
159
src/cairo-contour-private.h
Normal file
|
|
@ -0,0 +1,159 @@
|
|||
/* cairo - a vector graphics library with display and print output
|
||||
*
|
||||
* Copyright © 2011 Intel Corporation
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it either under the terms of the GNU Lesser General Public
|
||||
* License version 2.1 as published by the Free Software Foundation
|
||||
* (the "LGPL") or, at your option, under the terms of the Mozilla
|
||||
* Public License Version 1.1 (the "MPL"). If you do not alter this
|
||||
* notice, a recipient may use your version of this file under either
|
||||
* the MPL or the LGPL.
|
||||
*
|
||||
* You should have received a copy of the LGPL along with this library
|
||||
* in the file COPYING-LGPL-2.1; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA
|
||||
* You should have received a copy of the MPL along with this library
|
||||
* in the file COPYING-MPL-1.1
|
||||
*
|
||||
* The contents of this file are subject to the Mozilla Public License
|
||||
* Version 1.1 (the "License"); you may not use this file except in
|
||||
* compliance with the License. You may obtain a copy of the License at
|
||||
* http://www.mozilla.org/MPL/
|
||||
*
|
||||
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
|
||||
* OF ANY KIND, either express or implied. See the LGPL or the MPL for
|
||||
* the specific language governing rights and limitations.
|
||||
*
|
||||
* The Original Code is the cairo graphics library.
|
||||
*
|
||||
* The Initial Developer of the Original Code is Intel Corporation
|
||||
*
|
||||
* Contributor(s):
|
||||
* Chris Wilson <chris@chris-wilson.co.uk>
|
||||
*/
|
||||
|
||||
#ifndef CAIRO_CONTOUR_PRIVATE_H
|
||||
#define CAIRO_CONTOUR_PRIVATE_H
|
||||
|
||||
#include "cairo-types-private.h"
|
||||
#include "cairo-compiler-private.h"
|
||||
#include "cairo-error-private.h"
|
||||
#include "cairo-list-private.h"
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
CAIRO_BEGIN_DECLS
|
||||
|
||||
/* A contour is simply a closed chain of points that divide the infinite plane
|
||||
* into inside and outside. Each contour is a simple polygon, that is it
|
||||
* contains no holes or self-intersections, but maybe either concave or convex.
|
||||
*/
|
||||
|
||||
struct _cairo_contour_chain {
|
||||
cairo_point_t *points;
|
||||
int num_points, size_points;
|
||||
struct _cairo_contour_chain *next;
|
||||
};
|
||||
|
||||
struct _cairo_contour_iter {
|
||||
cairo_point_t *point;
|
||||
cairo_contour_chain_t *chain;
|
||||
};
|
||||
|
||||
struct _cairo_contour {
|
||||
cairo_list_t next;
|
||||
int direction;
|
||||
cairo_contour_chain_t chain, *tail;
|
||||
|
||||
cairo_point_t embedded_points[64];
|
||||
};
|
||||
|
||||
/* Initial definition of a shape is a set of contours (some representing holes) */
|
||||
struct _cairo_shape {
|
||||
cairo_list_t contours;
|
||||
};
|
||||
|
||||
typedef struct _cairo_shape cairo_shape_t;
|
||||
|
||||
#if 0
|
||||
cairo_private cairo_status_t
|
||||
_cairo_shape_init_from_polygon (cairo_shape_t *shape,
|
||||
const cairo_polygon_t *polygon);
|
||||
|
||||
cairo_private cairo_status_t
|
||||
_cairo_shape_reduce (cairo_shape_t *shape, double tolerance);
|
||||
#endif
|
||||
|
||||
cairo_private void
|
||||
_cairo_contour_init (cairo_contour_t *contour,
|
||||
int direction);
|
||||
|
||||
cairo_private cairo_int_status_t
|
||||
__cairo_contour_add_point (cairo_contour_t *contour,
|
||||
const cairo_point_t *point);
|
||||
|
||||
static inline cairo_int_status_t
|
||||
_cairo_contour_add_point (cairo_contour_t *contour,
|
||||
const cairo_point_t *point)
|
||||
{
|
||||
struct _cairo_contour_chain *tail = contour->tail;
|
||||
|
||||
if (unlikely (tail->num_points == tail->size_points))
|
||||
return __cairo_contour_add_point (contour, point);
|
||||
|
||||
tail->points[tail->num_points++] = *point;
|
||||
return CAIRO_INT_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
static inline cairo_point_t *
|
||||
_cairo_contour_first_point (cairo_contour_t *c)
|
||||
{
|
||||
return &c->chain.points[0];
|
||||
}
|
||||
|
||||
static inline cairo_point_t *
|
||||
_cairo_contour_last_point (cairo_contour_t *c)
|
||||
{
|
||||
return &c->tail->points[c->tail->num_points-1];
|
||||
}
|
||||
|
||||
cairo_private void
|
||||
_cairo_contour_simplify (cairo_contour_t *contour, double tolerance);
|
||||
|
||||
cairo_private void
|
||||
_cairo_contour_reverse (cairo_contour_t *contour);
|
||||
|
||||
cairo_private cairo_int_status_t
|
||||
_cairo_contour_add (cairo_contour_t *dst,
|
||||
const cairo_contour_t *src);
|
||||
|
||||
cairo_private cairo_int_status_t
|
||||
_cairo_contour_add_reversed (cairo_contour_t *dst,
|
||||
const cairo_contour_t *src);
|
||||
|
||||
cairo_private void
|
||||
__cairo_contour_remove_last_chain (cairo_contour_t *contour);
|
||||
|
||||
static inline void
|
||||
_cairo_contour_remove_last_point (cairo_contour_t *contour)
|
||||
{
|
||||
if (contour->chain.num_points == 0)
|
||||
return;
|
||||
|
||||
if (--contour->tail->num_points == 0)
|
||||
__cairo_contour_remove_last_chain (contour);
|
||||
}
|
||||
|
||||
cairo_private void
|
||||
_cairo_contour_reset (cairo_contour_t *contour);
|
||||
|
||||
cairo_private void
|
||||
_cairo_contour_fini (cairo_contour_t *contour);
|
||||
|
||||
cairo_private void
|
||||
_cairo_debug_print_contour (FILE *file, cairo_contour_t *contour);
|
||||
|
||||
CAIRO_END_DECLS
|
||||
|
||||
#endif /* CAIRO_CONTOUR_PRIVATE_H */
|
||||
453
src/cairo-contour.c
Normal file
453
src/cairo-contour.c
Normal file
|
|
@ -0,0 +1,453 @@
|
|||
/*
|
||||
* Copyright © 2004 Carl Worth
|
||||
* Copyright © 2006 Red Hat, Inc.
|
||||
* Copyright © 2008 Chris Wilson
|
||||
* Copyright © 2011 Intel Corporation
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it either under the terms of the GNU Lesser General Public
|
||||
* License version 2.1 as published by the Free Software Foundation
|
||||
* (the "LGPL") or, at your option, under the terms of the Mozilla
|
||||
* Public License Version 1.1 (the "MPL"). If you do not alter this
|
||||
* notice, a recipient may use your version of this file under either
|
||||
* the MPL or the LGPL.
|
||||
*
|
||||
* You should have received a copy of the LGPL along with this library
|
||||
* in the file COPYING-LGPL-2.1; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA
|
||||
* You should have received a copy of the MPL along with this library
|
||||
* in the file COPYING-MPL-1.1
|
||||
*
|
||||
* The contents of this file are subject to the Mozilla Public License
|
||||
* Version 1.1 (the "License"); you may not use this file except in
|
||||
* compliance with the License. You may obtain a copy of the License at
|
||||
* http://www.mozilla.org/MPL/
|
||||
*
|
||||
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
|
||||
* OF ANY KIND, either express or implied. See the LGPL or the MPL for
|
||||
* the specific language governing rights and limitations.
|
||||
*
|
||||
* The Original Code is the cairo graphics library.
|
||||
*
|
||||
* The Initial Developer of the Original Code is Carl Worth
|
||||
*
|
||||
* Contributor(s):
|
||||
* Carl D. Worth <cworth@cworth.org>
|
||||
* Chris Wilson <chris@chris-wilson.co.uk>
|
||||
*/
|
||||
|
||||
#include "cairoint.h"
|
||||
|
||||
#include "cairo-error-private.h"
|
||||
#include "cairo-freelist-private.h"
|
||||
#include "cairo-combsort-private.h"
|
||||
#include "cairo-contour-private.h"
|
||||
|
||||
void
|
||||
_cairo_contour_init (cairo_contour_t *contour,
|
||||
int direction)
|
||||
{
|
||||
contour->direction = direction;
|
||||
contour->chain.points = contour->embedded_points;
|
||||
contour->chain.next = NULL;
|
||||
contour->chain.num_points = 0;
|
||||
contour->chain.size_points = ARRAY_LENGTH (contour->embedded_points);
|
||||
contour->tail = &contour->chain;
|
||||
}
|
||||
|
||||
cairo_int_status_t
|
||||
__cairo_contour_add_point (cairo_contour_t *contour,
|
||||
const cairo_point_t *point)
|
||||
{
|
||||
cairo_contour_chain_t *tail = contour->tail;
|
||||
cairo_contour_chain_t *next;
|
||||
|
||||
assert (tail->next == NULL);
|
||||
|
||||
next = _cairo_malloc_ab_plus_c (tail->size_points*2,
|
||||
sizeof (cairo_point_t),
|
||||
sizeof (cairo_contour_chain_t));
|
||||
if (unlikely (next == NULL))
|
||||
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
|
||||
|
||||
next->size_points = tail->size_points*2;
|
||||
next->num_points = 1;
|
||||
next->points = (cairo_point_t *)(next+1);
|
||||
next->next = NULL;
|
||||
tail->next = next;
|
||||
contour->tail = next;
|
||||
|
||||
next->points[0] = *point;
|
||||
return CAIRO_INT_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
static void
|
||||
first_inc (cairo_contour_t *contour,
|
||||
cairo_point_t **p,
|
||||
cairo_contour_chain_t **chain)
|
||||
{
|
||||
if (*p == (*chain)->points + (*chain)->num_points) {
|
||||
assert ((*chain)->next);
|
||||
*chain = (*chain)->next;
|
||||
*p = &(*chain)->points[0];
|
||||
} else
|
||||
++*p;
|
||||
}
|
||||
|
||||
static void
|
||||
last_dec (cairo_contour_t *contour,
|
||||
cairo_point_t **p,
|
||||
cairo_contour_chain_t **chain)
|
||||
{
|
||||
if (*p == (*chain)->points) {
|
||||
cairo_contour_chain_t *prev;
|
||||
assert (*chain != &contour->chain);
|
||||
for (prev = &contour->chain; prev->next != *chain; prev = prev->next)
|
||||
;
|
||||
*chain = prev;
|
||||
*p = &(*chain)->points[(*chain)->num_points-1];
|
||||
} else
|
||||
--*p;
|
||||
}
|
||||
|
||||
void
|
||||
_cairo_contour_reverse (cairo_contour_t *contour)
|
||||
{
|
||||
cairo_contour_chain_t *first_chain, *last_chain;
|
||||
cairo_point_t *first, *last;
|
||||
|
||||
contour->direction = -contour->direction;
|
||||
|
||||
if (contour->chain.num_points <= 1)
|
||||
return;
|
||||
|
||||
first_chain = &contour->chain;
|
||||
last_chain = contour->tail;
|
||||
|
||||
first = &first_chain->points[0];
|
||||
last = &last_chain->points[last_chain->num_points-1];
|
||||
|
||||
while (first != last) {
|
||||
cairo_point_t p;
|
||||
|
||||
p = *first;
|
||||
*first = *last;
|
||||
*last = p;
|
||||
|
||||
first_inc (contour, &first, &first_chain);
|
||||
last_dec (contour, &last, &last_chain);
|
||||
}
|
||||
}
|
||||
|
||||
cairo_int_status_t
|
||||
_cairo_contour_add (cairo_contour_t *dst,
|
||||
const cairo_contour_t *src)
|
||||
{
|
||||
const cairo_contour_chain_t *chain;
|
||||
cairo_int_status_t status;
|
||||
int i;
|
||||
|
||||
for (chain = &src->chain; chain; chain = chain->next) {
|
||||
for (i = 0; i < chain->num_points; i++) {
|
||||
status = _cairo_contour_add_point (dst, &chain->points[i]);
|
||||
if (unlikely (status))
|
||||
return status;
|
||||
}
|
||||
}
|
||||
|
||||
return CAIRO_INT_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
static inline cairo_bool_t
|
||||
iter_next (cairo_contour_iter_t *iter)
|
||||
{
|
||||
if (iter->point == &iter->chain->points[iter->chain->size_points-1]) {
|
||||
iter->chain = iter->chain->next;
|
||||
if (iter->chain == NULL)
|
||||
return FALSE;
|
||||
|
||||
iter->point = &iter->chain->points[0];
|
||||
return TRUE;
|
||||
} else {
|
||||
iter->point++;
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
static cairo_bool_t
|
||||
iter_equal (const cairo_contour_iter_t *i1,
|
||||
const cairo_contour_iter_t *i2)
|
||||
{
|
||||
return i1->chain == i2->chain && i1->point == i2->point;
|
||||
}
|
||||
|
||||
static void
|
||||
iter_init (cairo_contour_iter_t *iter, cairo_contour_t *contour)
|
||||
{
|
||||
iter->chain = &contour->chain;
|
||||
iter->point = &contour->chain.points[0];
|
||||
}
|
||||
|
||||
static void
|
||||
iter_init_last (cairo_contour_iter_t *iter, cairo_contour_t *contour)
|
||||
{
|
||||
iter->chain = contour->tail;
|
||||
iter->point = &contour->tail->points[contour->tail->num_points-1];
|
||||
}
|
||||
|
||||
static const cairo_contour_chain_t *prev_const_chain(const cairo_contour_t *contour,
|
||||
const cairo_contour_chain_t *chain)
|
||||
{
|
||||
const cairo_contour_chain_t *prev;
|
||||
|
||||
if (chain == &contour->chain)
|
||||
return NULL;
|
||||
|
||||
for (prev = &contour->chain; prev->next != chain; prev = prev->next)
|
||||
;
|
||||
|
||||
return prev;
|
||||
}
|
||||
|
||||
cairo_int_status_t
|
||||
_cairo_contour_add_reversed (cairo_contour_t *dst,
|
||||
const cairo_contour_t *src)
|
||||
{
|
||||
const cairo_contour_chain_t *last;
|
||||
cairo_int_status_t status;
|
||||
int i;
|
||||
|
||||
if (src->chain.num_points == 0)
|
||||
return CAIRO_INT_STATUS_SUCCESS;
|
||||
|
||||
for (last = src->tail; last; last = prev_const_chain (src, last)) {
|
||||
for (i = last->num_points-1; i >= 0; i--) {
|
||||
status = _cairo_contour_add_point (dst, &last->points[i]);
|
||||
if (unlikely (status))
|
||||
return status;
|
||||
}
|
||||
}
|
||||
|
||||
return CAIRO_INT_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
static cairo_uint64_t
|
||||
point_distance_sq (const cairo_point_t *p1,
|
||||
const cairo_point_t *p2)
|
||||
{
|
||||
int32_t dx = p1->x - p2->x;
|
||||
int32_t dy = p1->y - p2->y;
|
||||
return _cairo_int32x32_64_mul (dx, dx) + _cairo_int32x32_64_mul (dy, dy);
|
||||
}
|
||||
|
||||
#define DELETED(p) ((p)->x == INT_MIN && (p)->y == INT_MAX)
|
||||
#define MARK_DELETED(p) ((p)->x = INT_MIN, (p)->y = INT_MAX)
|
||||
|
||||
static cairo_bool_t
|
||||
_cairo_contour_simplify_chain (cairo_contour_t *contour, const double tolerance,
|
||||
const cairo_contour_iter_t *first,
|
||||
const cairo_contour_iter_t *last)
|
||||
{
|
||||
cairo_contour_iter_t iter, furthest;
|
||||
uint64_t max_error;
|
||||
int x0, y0;
|
||||
int nx, ny;
|
||||
int count;
|
||||
|
||||
iter = *first;
|
||||
iter_next (&iter);
|
||||
if (iter_equal (&iter, last))
|
||||
return FALSE;
|
||||
|
||||
x0 = first->point->x;
|
||||
y0 = first->point->y;
|
||||
nx = last->point->y - y0;
|
||||
ny = x0 - last->point->x;
|
||||
|
||||
count = 0;
|
||||
max_error = 0;
|
||||
do {
|
||||
cairo_point_t *p = iter.point;
|
||||
if (! DELETED(p)) {
|
||||
uint64_t d = (uint64_t)nx * (x0 - p->x) + (uint64_t)ny * (y0 - p->y);
|
||||
if (d * d > max_error) {
|
||||
max_error = d * d;
|
||||
furthest = iter;
|
||||
}
|
||||
count++;
|
||||
}
|
||||
iter_next (&iter);
|
||||
} while (! iter_equal (&iter, last));
|
||||
if (count == 0)
|
||||
return FALSE;
|
||||
|
||||
if (max_error > tolerance * ((uint64_t)nx * nx + (uint64_t)ny * ny)) {
|
||||
cairo_bool_t simplified;
|
||||
|
||||
simplified = FALSE;
|
||||
simplified |= _cairo_contour_simplify_chain (contour, tolerance,
|
||||
first, &furthest);
|
||||
simplified |= _cairo_contour_simplify_chain (contour, tolerance,
|
||||
&furthest, last);
|
||||
return simplified;
|
||||
} else {
|
||||
iter = *first;
|
||||
iter_next (&iter);
|
||||
do {
|
||||
MARK_DELETED (iter.point);
|
||||
iter_next (&iter);
|
||||
} while (! iter_equal (&iter, last));
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
_cairo_contour_simplify (cairo_contour_t *contour, double tolerance)
|
||||
{
|
||||
cairo_contour_chain_t *chain;
|
||||
cairo_point_t *last = NULL;
|
||||
cairo_contour_iter_t iter, furthest;
|
||||
cairo_bool_t simplified;
|
||||
uint64_t max = 0;
|
||||
int i;
|
||||
|
||||
if (contour->chain.num_points <= 2)
|
||||
return;
|
||||
|
||||
tolerance = tolerance * CAIRO_FIXED_ONE;
|
||||
tolerance *= tolerance;
|
||||
|
||||
/* stage 1: vertex reduction */
|
||||
for (chain = &contour->chain; chain; chain = chain->next) {
|
||||
for (i = 0; i < chain->num_points; i++) {
|
||||
if (last == NULL ||
|
||||
point_distance_sq (last, &chain->points[i]) > tolerance) {
|
||||
last = &chain->points[i];
|
||||
} else {
|
||||
MARK_DELETED (&chain->points[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* stage2: polygon simplification using Douglas-Peucker */
|
||||
simplified = FALSE;
|
||||
do {
|
||||
last = &contour->chain.points[0];
|
||||
iter_init (&furthest, contour);
|
||||
max = 0;
|
||||
for (chain = &contour->chain; chain; chain = chain->next) {
|
||||
for (i = 0; i < chain->num_points; i++) {
|
||||
uint64_t d;
|
||||
|
||||
if (DELETED (&chain->points[i]))
|
||||
continue;
|
||||
|
||||
d = point_distance_sq (last, &chain->points[i]);
|
||||
if (d > max) {
|
||||
furthest.chain = chain;
|
||||
furthest.point = &chain->points[i];
|
||||
max = d;
|
||||
}
|
||||
}
|
||||
}
|
||||
assert (max);
|
||||
|
||||
simplified = FALSE;
|
||||
iter_init (&iter, contour);
|
||||
simplified |= _cairo_contour_simplify_chain (contour, tolerance,
|
||||
&iter, &furthest);
|
||||
|
||||
iter_init_last (&iter, contour);
|
||||
if (! iter_equal (&furthest, &iter))
|
||||
simplified |= _cairo_contour_simplify_chain (contour, tolerance,
|
||||
&furthest, &iter);
|
||||
} while (simplified);
|
||||
|
||||
iter_init (&iter, contour);
|
||||
for (chain = &contour->chain; chain; chain = chain->next) {
|
||||
int num_points = chain->num_points;
|
||||
chain->num_points = 0;
|
||||
for (i = 0; i < num_points; i++) {
|
||||
if (! DELETED(&chain->points[i])) {
|
||||
if (iter.point != &chain->points[i])
|
||||
*iter.point = chain->points[i];
|
||||
iter.chain->num_points++;
|
||||
iter_next (&iter);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (iter.chain) {
|
||||
cairo_contour_chain_t *next;
|
||||
|
||||
for (chain = iter.chain->next; chain; chain = next) {
|
||||
next = chain->next;
|
||||
free (chain);
|
||||
}
|
||||
|
||||
iter.chain->next = NULL;
|
||||
contour->tail = iter.chain;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
_cairo_contour_reset (cairo_contour_t *contour)
|
||||
{
|
||||
_cairo_contour_fini (contour);
|
||||
_cairo_contour_init (contour, contour->direction);
|
||||
}
|
||||
|
||||
void
|
||||
_cairo_contour_fini (cairo_contour_t *contour)
|
||||
{
|
||||
cairo_contour_chain_t *chain, *next;
|
||||
|
||||
for (chain = contour->chain.next; chain; chain = next) {
|
||||
next = chain->next;
|
||||
free (chain);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
_cairo_debug_print_contour (FILE *file, cairo_contour_t *contour)
|
||||
{
|
||||
cairo_contour_chain_t *chain;
|
||||
int num_points, size_points;
|
||||
int i;
|
||||
|
||||
num_points = 0;
|
||||
size_points = 0;
|
||||
for (chain = &contour->chain; chain; chain = chain->next) {
|
||||
num_points += chain->num_points;
|
||||
size_points += chain->size_points;
|
||||
}
|
||||
|
||||
fprintf (file, "contour: direction=%d, num_points=%d / %d\n",
|
||||
contour->direction, num_points, size_points);
|
||||
|
||||
num_points = 0;
|
||||
for (chain = &contour->chain; chain; chain = chain->next) {
|
||||
for (i = 0; i < chain->num_points; i++) {
|
||||
fprintf (file, " [%d] = (%f, %f)\n",
|
||||
num_points++,
|
||||
_cairo_fixed_to_double (chain->points[i].x),
|
||||
_cairo_fixed_to_double (chain->points[i].y));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
__cairo_contour_remove_last_chain (cairo_contour_t *contour)
|
||||
{
|
||||
cairo_contour_chain_t *chain;
|
||||
|
||||
if (contour->tail == &contour->chain)
|
||||
return;
|
||||
|
||||
for (chain = &contour->chain; chain->next != contour->tail; chain = chain->next)
|
||||
;
|
||||
free (contour->tail);
|
||||
contour->tail = chain;
|
||||
chain->next = NULL;
|
||||
}
|
||||
|
|
@ -1128,7 +1128,7 @@ _cpf_curve_to (void *closure,
|
|||
cairo_point_t *p0 = &cpf->current_point;
|
||||
|
||||
if (! _cairo_spline_init (&spline,
|
||||
cpf->line_to,
|
||||
(cairo_spline_add_point_func_t)cpf->line_to,
|
||||
cpf->closure,
|
||||
p0, p1, p2, p3))
|
||||
{
|
||||
|
|
|
|||
|
|
@ -217,7 +217,7 @@ _cairo_in_fill_curve_to (void *closure,
|
|||
|
||||
/* XXX Investigate direct inspection of the inflections? */
|
||||
if (! _cairo_spline_init (&spline,
|
||||
_cairo_in_fill_line_to,
|
||||
(cairo_spline_add_point_func_t)_cairo_in_fill_line_to,
|
||||
in_fill,
|
||||
&in_fill->current_point, b, c, d))
|
||||
{
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -1118,7 +1118,7 @@ _cairo_stroker_curve_to (void *closure,
|
|||
_cairo_stroker_line_to;
|
||||
|
||||
if (! _cairo_spline_init (&spline,
|
||||
line_to, stroker,
|
||||
(cairo_spline_add_point_func_t)line_to, stroker,
|
||||
&stroker->current_point, b, c, d))
|
||||
{
|
||||
return line_to (closure, d);
|
||||
|
|
|
|||
|
|
@ -38,12 +38,14 @@
|
|||
#include "cairoint.h"
|
||||
|
||||
#include "cairo-boxes-private.h"
|
||||
#include "cairo-contour-private.h"
|
||||
#include "cairo-error-private.h"
|
||||
|
||||
static void
|
||||
_cairo_polygon_add_edge (cairo_polygon_t *polygon,
|
||||
const cairo_point_t *p1,
|
||||
const cairo_point_t *p2);
|
||||
const cairo_point_t *p2,
|
||||
int dir);
|
||||
|
||||
void
|
||||
_cairo_polygon_init (cairo_polygon_t *polygon,
|
||||
|
|
@ -131,12 +133,12 @@ _cairo_polygon_init_boxes (cairo_polygon_t *polygon,
|
|||
p1 = chunk->base[i].p1;
|
||||
p2.x = p1.x;
|
||||
p2.y = chunk->base[i].p2.y;
|
||||
_cairo_polygon_add_edge (polygon, &p1, &p2);
|
||||
_cairo_polygon_add_edge (polygon, &p1, &p2, 1);
|
||||
|
||||
p1 = chunk->base[i].p2;
|
||||
p2.x = p1.x;
|
||||
p2.y = chunk->base[i].p1.y;
|
||||
_cairo_polygon_add_edge (polygon, &p1, &p2);
|
||||
_cairo_polygon_add_edge (polygon, &p1, &p2, 1);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -178,12 +180,12 @@ _cairo_polygon_init_box_array (cairo_polygon_t *polygon,
|
|||
p1 = boxes[i].p1;
|
||||
p2.x = p1.x;
|
||||
p2.y = boxes[i].p2.y;
|
||||
_cairo_polygon_add_edge (polygon, &p1, &p2);
|
||||
_cairo_polygon_add_edge (polygon, &p1, &p2, 1);
|
||||
|
||||
p1 = boxes[i].p2;
|
||||
p2.x = p1.x;
|
||||
p2.y = boxes[i].p1.y;
|
||||
_cairo_polygon_add_edge (polygon, &p1, &p2);
|
||||
_cairo_polygon_add_edge (polygon, &p1, &p2, 1);
|
||||
}
|
||||
|
||||
return polygon->status;
|
||||
|
|
@ -406,20 +408,17 @@ _add_clipped_edge (cairo_polygon_t *polygon,
|
|||
static void
|
||||
_cairo_polygon_add_edge (cairo_polygon_t *polygon,
|
||||
const cairo_point_t *p1,
|
||||
const cairo_point_t *p2)
|
||||
const cairo_point_t *p2,
|
||||
int dir)
|
||||
{
|
||||
int dir;
|
||||
|
||||
/* drop horizontal edges */
|
||||
if (p1->y == p2->y)
|
||||
return;
|
||||
|
||||
if (p1->y < p2->y) {
|
||||
dir = 1;
|
||||
} else {
|
||||
if (p1->y > p2->y) {
|
||||
const cairo_point_t *t;
|
||||
t = p1, p1 = p2, p2 = t;
|
||||
dir = -1;
|
||||
dir = -dir;
|
||||
}
|
||||
|
||||
if (polygon->num_limits) {
|
||||
|
|
@ -439,7 +438,7 @@ _cairo_polygon_add_external_edge (void *polygon,
|
|||
const cairo_point_t *p1,
|
||||
const cairo_point_t *p2)
|
||||
{
|
||||
_cairo_polygon_add_edge (polygon, p1, p2);
|
||||
_cairo_polygon_add_edge (polygon, p1, p2, 1);
|
||||
return _cairo_polygon_status (polygon);
|
||||
}
|
||||
|
||||
|
|
@ -469,3 +468,26 @@ _cairo_polygon_add_line (cairo_polygon_t *polygon,
|
|||
|
||||
return polygon->status;
|
||||
}
|
||||
|
||||
cairo_status_t
|
||||
_cairo_polygon_add_contour (cairo_polygon_t *polygon,
|
||||
const cairo_contour_t *contour)
|
||||
{
|
||||
const struct _cairo_contour_chain *chain;
|
||||
const cairo_point_t *prev = NULL;
|
||||
int i;
|
||||
|
||||
if (contour->chain.num_points <= 1)
|
||||
return CAIRO_INT_STATUS_SUCCESS;
|
||||
|
||||
prev = &contour->chain.points[0];
|
||||
for (chain = &contour->chain; chain; chain = chain->next) {
|
||||
for (i = 0; i < chain->num_points; i++) {
|
||||
_cairo_polygon_add_edge (polygon, prev, &chain->points[i],
|
||||
contour->direction);
|
||||
prev = &chain->points[i];
|
||||
}
|
||||
}
|
||||
|
||||
return polygon->status;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -67,22 +67,27 @@ _cairo_spline_init (cairo_spline_t *spline,
|
|||
else if (b->x != d->x || b->y != d->y)
|
||||
_cairo_slope_init (&spline->final_slope, &spline->knots.b, &spline->knots.d);
|
||||
else
|
||||
_cairo_slope_init (&spline->final_slope, &spline->knots.a, &spline->knots.d);
|
||||
return FALSE; /* just treat this as a straight-line from a -> d */
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static cairo_status_t
|
||||
_cairo_spline_add_point (cairo_spline_t *spline, cairo_point_t *point)
|
||||
_cairo_spline_add_point (cairo_spline_t *spline,
|
||||
const cairo_point_t *point,
|
||||
const cairo_point_t *knot)
|
||||
{
|
||||
cairo_point_t *prev;
|
||||
cairo_slope_t slope;
|
||||
|
||||
prev = &spline->last_point;
|
||||
if (prev->x == point->x && prev->y == point->y)
|
||||
return CAIRO_STATUS_SUCCESS;
|
||||
|
||||
_cairo_slope_init (&slope, point, knot);
|
||||
|
||||
spline->last_point = *point;
|
||||
return spline->add_point_func (spline->closure, point);
|
||||
return spline->add_point_func (spline->closure, point, &slope);
|
||||
}
|
||||
|
||||
static void
|
||||
|
|
@ -184,13 +189,15 @@ _cairo_spline_error_squared (const cairo_spline_knots_t *knots)
|
|||
}
|
||||
|
||||
static cairo_status_t
|
||||
_cairo_spline_decompose_into (cairo_spline_knots_t *s1, double tolerance_squared, cairo_spline_t *result)
|
||||
_cairo_spline_decompose_into (cairo_spline_knots_t *s1,
|
||||
double tolerance_squared,
|
||||
cairo_spline_t *result)
|
||||
{
|
||||
cairo_spline_knots_t s2;
|
||||
cairo_status_t status;
|
||||
|
||||
if (_cairo_spline_error_squared (s1) < tolerance_squared)
|
||||
return _cairo_spline_add_point (result, &s1->a);
|
||||
return _cairo_spline_add_point (result, &s1->a, &s1->b);
|
||||
|
||||
_de_casteljau (s1, &s2);
|
||||
|
||||
|
|
@ -206,6 +213,7 @@ _cairo_spline_decompose (cairo_spline_t *spline, double tolerance)
|
|||
{
|
||||
cairo_spline_knots_t s1;
|
||||
cairo_status_t status;
|
||||
cairo_slope_t slope;
|
||||
|
||||
s1 = spline->knots;
|
||||
spline->last_point = s1.a;
|
||||
|
|
@ -213,7 +221,8 @@ _cairo_spline_decompose (cairo_spline_t *spline, double tolerance)
|
|||
if (unlikely (status))
|
||||
return status;
|
||||
|
||||
return _cairo_spline_add_point (spline, &spline->knots.d);
|
||||
_cairo_slope_init (&slope, &spline->knots.c, &spline->knots.d);
|
||||
return spline->add_point_func (spline->closure, &spline->knots.d, &slope);
|
||||
}
|
||||
|
||||
/* Note: this function is only good for computing bounds in device space. */
|
||||
|
|
@ -325,7 +334,7 @@ _cairo_spline_bound (cairo_spline_add_point_func_t add_point_func,
|
|||
c = -y0 + y1;
|
||||
FIND_EXTREMES (a, b, c);
|
||||
|
||||
status = add_point_func (closure, p0);
|
||||
status = add_point_func (closure, p0, NULL);
|
||||
if (unlikely (status))
|
||||
return status;
|
||||
|
||||
|
|
@ -359,10 +368,10 @@ _cairo_spline_bound (cairo_spline_add_point_func_t add_point_func,
|
|||
|
||||
p.x = _cairo_fixed_from_double (x);
|
||||
p.y = _cairo_fixed_from_double (y);
|
||||
status = add_point_func (closure, &p);
|
||||
status = add_point_func (closure, &p, NULL);
|
||||
if (unlikely (status))
|
||||
return status;
|
||||
}
|
||||
|
||||
return add_point_func (closure, p3);
|
||||
return add_point_func (closure, p3, NULL);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -63,6 +63,9 @@ typedef struct _cairo_clip cairo_clip_t;
|
|||
typedef struct _cairo_clip_path cairo_clip_path_t;
|
||||
typedef struct _cairo_color cairo_color_t;
|
||||
typedef struct _cairo_color_stop cairo_color_stop_t;
|
||||
typedef struct _cairo_contour cairo_contour_t;
|
||||
typedef struct _cairo_contour_chain cairo_contour_chain_t;
|
||||
typedef struct _cairo_contour_iter cairo_contour_iter_t;
|
||||
typedef struct _cairo_device_backend cairo_device_backend_t;
|
||||
typedef struct _cairo_font_face_backend cairo_font_face_backend_t;
|
||||
typedef struct _cairo_gstate cairo_gstate_t;
|
||||
|
|
@ -312,7 +315,8 @@ typedef struct _cairo_polygon {
|
|||
|
||||
typedef cairo_warn cairo_status_t
|
||||
(*cairo_spline_add_point_func_t) (void *closure,
|
||||
const cairo_point_t *point);
|
||||
const cairo_point_t *point,
|
||||
const cairo_slope_t *tangent);
|
||||
|
||||
typedef struct _cairo_spline_knots {
|
||||
cairo_point_t a, b, c, d;
|
||||
|
|
|
|||
|
|
@ -1030,7 +1030,9 @@ typedef struct _cairo_stroke_face {
|
|||
cairo_point_t point;
|
||||
cairo_point_t cw;
|
||||
cairo_slope_t dev_vector;
|
||||
cairo_point_double_t dev_slope;
|
||||
cairo_point_double_t usr_vector;
|
||||
double length;
|
||||
} cairo_stroke_face_t;
|
||||
|
||||
/* cairo.c */
|
||||
|
|
@ -2069,6 +2071,10 @@ _cairo_polygon_add_external_edge (void *polygon,
|
|||
const cairo_point_t *p1,
|
||||
const cairo_point_t *p2);
|
||||
|
||||
cairo_private cairo_status_t
|
||||
_cairo_polygon_add_contour (cairo_polygon_t *polygon,
|
||||
const cairo_contour_t *contour);
|
||||
|
||||
cairo_private cairo_status_t
|
||||
_cairo_polygon_reduce (cairo_polygon_t *polygon,
|
||||
cairo_fill_rule_t fill_rule);
|
||||
|
|
|
|||
2
util/.gitignore
vendored
2
util/.gitignore
vendored
|
|
@ -2,8 +2,10 @@
|
|||
.libs
|
||||
Makefile
|
||||
Makefile.in
|
||||
show-contour
|
||||
show-edges
|
||||
show-events
|
||||
show-polygon
|
||||
show-traps
|
||||
xml-to-trace
|
||||
trace-to-xml
|
||||
|
|
|
|||
|
|
@ -32,7 +32,7 @@ AM_CPPFLAGS = -I$(top_srcdir)/src \
|
|||
-I$(top_srcdir)/util/cairo-script \
|
||||
$(CAIRO_CFLAGS)
|
||||
|
||||
EXTRA_PROGRAMS += show-traps show-edges show-polygon show-events
|
||||
EXTRA_PROGRAMS += show-contour show-traps show-edges show-polygon show-events
|
||||
if CAIRO_HAS_INTERPRETER
|
||||
EXTRA_PROGRAMS += trace-to-xml xml-to-trace
|
||||
endif
|
||||
|
|
@ -56,6 +56,11 @@ show_edges_CFLAGS = $(gtk_CFLAGS)
|
|||
#show_edges_LDADD = $(top_builddir)/src/libcairo.la $(gtk_LIBS)
|
||||
show_edges_LDADD = $(gtk_LIBS)
|
||||
|
||||
show_contour_SOURCES = show-contour.c
|
||||
show_contour_CFLAGS = $(gtk_CFLAGS)
|
||||
#show_contour_LDADD = $(top_builddir)/src/libcairo.la $(gtk_LIBS)
|
||||
show_contour_LDADD = $(gtk_LIBS)
|
||||
|
||||
show_events_SOURCES = show-events.c
|
||||
show_events_CFLAGS = $(gtk_CFLAGS)
|
||||
#show_events_LDADD = $(top_builddir)/src/libcairo.la $(gtk_LIBS)
|
||||
|
|
|
|||
667
util/show-contour.c
Normal file
667
util/show-contour.c
Normal file
|
|
@ -0,0 +1,667 @@
|
|||
#define _GNU_SOURCE
|
||||
#include <gtk/gtk.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <gdk/gdkkeysyms.h>
|
||||
#include <math.h>
|
||||
|
||||
typedef struct _point {
|
||||
gdouble x, y;
|
||||
} point_t;
|
||||
typedef struct _box {
|
||||
point_t p1, p2;
|
||||
} box_t;
|
||||
|
||||
typedef struct _contour {
|
||||
struct _contour *next, *prev;
|
||||
int direction;
|
||||
int num_points;
|
||||
int size;
|
||||
point_t points[0];
|
||||
} contour_t;
|
||||
|
||||
typedef struct _TrapView {
|
||||
GtkWidget widget;
|
||||
|
||||
cairo_surface_t *pixmap;
|
||||
int pixmap_width, pixmap_height;
|
||||
|
||||
box_t extents;
|
||||
contour_t *contours;
|
||||
|
||||
double px, py;
|
||||
|
||||
gint mag_x, mag_y;
|
||||
gint mag_size;
|
||||
gdouble mag_zoom;
|
||||
gboolean in_mag_drag;
|
||||
gint mag_drag_x, mag_drag_y;
|
||||
} TrapView;
|
||||
|
||||
typedef struct _TrapViewClass {
|
||||
GtkWidgetClass parent_class;
|
||||
} TrapViewClass;
|
||||
|
||||
G_DEFINE_TYPE (TrapView, trap_view, GTK_TYPE_WIDGET)
|
||||
|
||||
static cairo_surface_t *
|
||||
pixmap_create (TrapView *self, cairo_surface_t *target)
|
||||
{
|
||||
cairo_surface_t *surface =
|
||||
cairo_surface_create_similar (target, CAIRO_CONTENT_COLOR,
|
||||
self->widget.allocation.width,
|
||||
self->widget.allocation.height);
|
||||
cairo_t *cr = cairo_create (surface);
|
||||
contour_t *contour;
|
||||
gdouble sf_x, sf_y, sf;
|
||||
gdouble mid, dim;
|
||||
gdouble x0, y0;
|
||||
int n;
|
||||
box_t extents;
|
||||
|
||||
cairo_set_source_rgb (cr, 1, 1, 1);
|
||||
cairo_paint (cr);
|
||||
|
||||
if (self->contours == NULL) {
|
||||
cairo_destroy(cr);
|
||||
return surface;
|
||||
}
|
||||
|
||||
extents = self->extents;
|
||||
|
||||
mid = (extents.p2.x + extents.p1.x) / 2.;
|
||||
dim = (extents.p2.x - extents.p1.x) / 2. * 1.25;
|
||||
sf_x = self->widget.allocation.width / dim / 2;
|
||||
|
||||
mid = (extents.p2.y + extents.p1.y) / 2.;
|
||||
dim = (extents.p2.y - extents.p1.y) / 2. * 1.25;
|
||||
sf_y = self->widget.allocation.height / dim / 2;
|
||||
|
||||
sf = MIN (sf_x, sf_y);
|
||||
|
||||
mid = (extents.p2.x + extents.p1.x) / 2.;
|
||||
dim = sf_x / sf * (extents.p2.x - extents.p1.x) / 2. * 1.25;
|
||||
x0 = mid - dim;
|
||||
mid = (extents.p2.y + extents.p1.y) / 2.;
|
||||
dim = sf_y / sf * (extents.p2.y - extents.p1.y) / 2. * 1.25;
|
||||
y0 = mid - dim;
|
||||
|
||||
for (contour = self->contours; contour; contour = contour->next) {
|
||||
if (contour->num_points == 0)
|
||||
continue;
|
||||
|
||||
cairo_save (cr); {
|
||||
cairo_scale (cr, sf, sf);
|
||||
cairo_translate (cr, -x0, -y0);
|
||||
switch (contour->direction) {
|
||||
case -1:
|
||||
cairo_set_source_rgb (cr, 0.0, 0.0, 1.0);
|
||||
break;
|
||||
case 0:
|
||||
cairo_set_source_rgb (cr, 0.0, 1.0, 0.0);
|
||||
break;
|
||||
case 1:
|
||||
cairo_set_source_rgb (cr, 1.0, 0.0, 0.0);
|
||||
break;
|
||||
}
|
||||
{
|
||||
const point_t *p = &contour->points[0];
|
||||
cairo_arc (cr, p->x, p->y, 4/sf, 0, 2 * M_PI);
|
||||
cairo_save (cr);
|
||||
cairo_identity_matrix (cr);
|
||||
cairo_stroke (cr);
|
||||
cairo_restore (cr);
|
||||
}
|
||||
for (n = 0; n < contour->num_points; n++) {
|
||||
const point_t *p = &contour->points[n];
|
||||
cairo_arc (cr, p->x, p->y, 2/sf, 0, 2 * M_PI);
|
||||
cairo_fill (cr);
|
||||
}
|
||||
for (n = 0; n < contour->num_points; n++) {
|
||||
const point_t *p = &contour->points[n];
|
||||
cairo_line_to (cr, p->x, p->y);
|
||||
}
|
||||
} cairo_restore (cr);
|
||||
|
||||
switch (contour->direction) {
|
||||
case -1:
|
||||
cairo_set_source_rgb (cr, 0.3, 0.3, 0.9);
|
||||
break;
|
||||
case 0:
|
||||
cairo_set_source_rgb (cr, 0.3, 0.9, 0.3);
|
||||
break;
|
||||
case 1:
|
||||
cairo_set_source_rgb (cr, 0.9, 0.3, 0.3);
|
||||
break;
|
||||
}
|
||||
cairo_set_line_width (cr, 1.);
|
||||
cairo_stroke (cr);
|
||||
}
|
||||
|
||||
cairo_destroy (cr);
|
||||
return surface;
|
||||
}
|
||||
|
||||
static void
|
||||
trap_view_draw (TrapView *self, cairo_t *cr)
|
||||
{
|
||||
contour_t *contour;
|
||||
gdouble sf_x, sf_y, sf;
|
||||
gdouble mid, dim;
|
||||
gdouble x0, y0;
|
||||
int n;
|
||||
box_t extents;
|
||||
|
||||
extents = self->extents;
|
||||
|
||||
mid = (extents.p2.x + extents.p1.x) / 2.;
|
||||
dim = (extents.p2.x - extents.p1.x) / 2. * 1.25;
|
||||
sf_x = self->widget.allocation.width / dim / 2;
|
||||
|
||||
mid = (extents.p2.y + extents.p1.y) / 2.;
|
||||
dim = (extents.p2.y - extents.p1.y) / 2. * 1.25;
|
||||
sf_y = self->widget.allocation.height / dim / 2;
|
||||
|
||||
sf = MIN (sf_x, sf_y);
|
||||
|
||||
mid = (extents.p2.x + extents.p1.x) / 2.;
|
||||
dim = sf_x / sf * (extents.p2.x - extents.p1.x) / 2. * 1.25;
|
||||
x0 = mid - dim;
|
||||
mid = (extents.p2.y + extents.p1.y) / 2.;
|
||||
dim = sf_y / sf * (extents.p2.y - extents.p1.y) / 2. * 1.25;
|
||||
y0 = mid - dim;
|
||||
|
||||
if (self->pixmap_width != self->widget.allocation.width ||
|
||||
self->pixmap_height != self->widget.allocation.height)
|
||||
{
|
||||
cairo_surface_destroy (self->pixmap);
|
||||
self->pixmap = pixmap_create (self, cairo_get_target (cr));
|
||||
self->pixmap_width = self->widget.allocation.width;
|
||||
self->pixmap_height = self->widget.allocation.height;
|
||||
}
|
||||
|
||||
cairo_set_source_surface (cr, self->pixmap, 0, 0);
|
||||
cairo_paint (cr);
|
||||
|
||||
if (self->contours == NULL)
|
||||
return;
|
||||
|
||||
/* draw a zoom view of the area around the mouse */
|
||||
if (1) {
|
||||
double zoom = self->mag_zoom;
|
||||
int size = self->mag_size;
|
||||
int mag_x = self->mag_x;
|
||||
int mag_y = self->mag_y;
|
||||
|
||||
if (1) {
|
||||
if (self->px + size < self->widget.allocation.width/2)
|
||||
mag_x = self->px + size/4;
|
||||
else
|
||||
mag_x = self->px - size/4 - size;
|
||||
mag_y = self->py - size/2;
|
||||
if (mag_y < 0)
|
||||
mag_y = 0;
|
||||
if (mag_y + size > self->widget.allocation.height)
|
||||
mag_y = self->widget.allocation.height - size;
|
||||
}
|
||||
|
||||
cairo_save (cr); {
|
||||
/* bottom right */
|
||||
cairo_rectangle (cr, mag_x, mag_y, size, size);
|
||||
cairo_stroke_preserve (cr);
|
||||
cairo_set_source_rgb (cr, 1, 1, 1);
|
||||
cairo_fill_preserve (cr);
|
||||
cairo_clip (cr);
|
||||
|
||||
/* compute roi in extents */
|
||||
cairo_translate (cr, mag_x + size/2, mag_y + size/2);
|
||||
|
||||
cairo_save (cr); {
|
||||
for (contour = self->contours; contour; contour = contour->next) {
|
||||
if (contour->num_points == 0)
|
||||
continue;
|
||||
|
||||
cairo_save (cr); {
|
||||
cairo_scale (cr, zoom, zoom);
|
||||
cairo_translate (cr, -(self->px / sf + x0), -(self->py /sf + y0));
|
||||
switch (contour->direction) {
|
||||
case -1:
|
||||
cairo_set_source_rgb (cr, 0.0, 0.0, 1.0);
|
||||
break;
|
||||
case 0:
|
||||
cairo_set_source_rgb (cr, 0.0, 1.0, 0.0);
|
||||
break;
|
||||
case 1:
|
||||
cairo_set_source_rgb (cr, 1.0, 0.0, 0.0);
|
||||
break;
|
||||
}
|
||||
{
|
||||
const point_t *p = &contour->points[0];
|
||||
cairo_arc (cr, p->x, p->y, 4/zoom, 0, 2 * M_PI);
|
||||
cairo_save (cr);
|
||||
cairo_identity_matrix (cr);
|
||||
cairo_stroke (cr);
|
||||
cairo_restore (cr);
|
||||
}
|
||||
for (n = 0; n < contour->num_points; n++) {
|
||||
const point_t *p = &contour->points[n];
|
||||
cairo_arc (cr, p->x, p->y, 2/zoom, 0, 2 * M_PI);
|
||||
cairo_fill (cr);
|
||||
}
|
||||
for (n = 0; n < contour->num_points; n++) {
|
||||
const point_t *p = &contour->points[n];
|
||||
cairo_line_to (cr, p->x, p->y);
|
||||
}
|
||||
} cairo_restore (cr);
|
||||
|
||||
switch (contour->direction) {
|
||||
case -1:
|
||||
cairo_set_source_rgb (cr, 0.3, 0.3, 0.9);
|
||||
break;
|
||||
case 0:
|
||||
cairo_set_source_rgb (cr, 0.3, 0.9, 0.3);
|
||||
break;
|
||||
case 1:
|
||||
cairo_set_source_rgb (cr, 0.9, 0.3, 0.3);
|
||||
break;
|
||||
}
|
||||
cairo_stroke (cr);
|
||||
}
|
||||
} cairo_restore (cr);
|
||||
|
||||
/* grid */
|
||||
cairo_save (cr); {
|
||||
int i;
|
||||
|
||||
cairo_translate (cr,
|
||||
-zoom*fmod (self->px/sf + x0, 1.),
|
||||
-zoom*fmod (self->py/sf + y0, 1.));
|
||||
zoom /= 2;
|
||||
for (i = -size/2/zoom; i <= size/2/zoom + 1; i+=2) {
|
||||
cairo_move_to (cr, zoom*i, -size/2);
|
||||
cairo_line_to (cr, zoom*i, size/2 + zoom);
|
||||
cairo_move_to (cr, -size/2, zoom*i);
|
||||
cairo_line_to (cr, size/2 + zoom, zoom*i);
|
||||
}
|
||||
zoom *= 2;
|
||||
cairo_set_source_rgba (cr, .7, .7, .7, .5);
|
||||
cairo_set_line_width (cr, 1.);
|
||||
cairo_stroke (cr);
|
||||
|
||||
for (i = -size/2/zoom - 1; i <= size/2/zoom + 1; i++) {
|
||||
cairo_move_to (cr, zoom*i, -size/2);
|
||||
cairo_line_to (cr, zoom*i, size/2 + zoom);
|
||||
cairo_move_to (cr, -size/2, zoom*i);
|
||||
cairo_line_to (cr, size/2 + zoom, zoom*i);
|
||||
}
|
||||
cairo_set_source_rgba (cr, .1, .1, .1, .5);
|
||||
cairo_set_line_width (cr, 2.);
|
||||
cairo_stroke (cr);
|
||||
} cairo_restore (cr);
|
||||
|
||||
} cairo_restore (cr);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static gdouble
|
||||
edge_length (const point_t *p1, const point_t *p2)
|
||||
{
|
||||
return hypot (p2->x - p1->x, p2->y - p1->y);
|
||||
}
|
||||
|
||||
static gdouble
|
||||
contour_compute_total_length (const contour_t *contour)
|
||||
{
|
||||
int n;
|
||||
gdouble len = 0.;
|
||||
for (n = 1; n < contour->num_points; n++)
|
||||
len += edge_length (&contour->points[n-1], &contour->points[n]);
|
||||
return len;
|
||||
}
|
||||
|
||||
static void
|
||||
trap_view_draw_labels (TrapView *self, cairo_t *cr)
|
||||
{
|
||||
contour_t *contour;
|
||||
int y = 12;
|
||||
|
||||
for (contour = self->contours; contour; contour = contour->next) {
|
||||
double total_length = contour_compute_total_length (contour) / 256.;
|
||||
PangoLayout *layout;
|
||||
gint width, height;
|
||||
GString *string;
|
||||
gchar *str;
|
||||
|
||||
if (contour->num_points == 0)
|
||||
continue;
|
||||
|
||||
string = g_string_new (NULL);
|
||||
g_string_append_printf (string,
|
||||
"Number of points:\t%d\n"
|
||||
"Total length of contour: \t%.2f",
|
||||
contour->num_points,
|
||||
total_length);
|
||||
|
||||
str = g_string_free (string, FALSE);
|
||||
layout = gtk_widget_create_pango_layout (&self->widget, str);
|
||||
g_free (str);
|
||||
|
||||
pango_layout_get_pixel_size (layout, &width, &height);
|
||||
|
||||
switch (contour->direction) {
|
||||
case -1:
|
||||
cairo_set_source_rgb (cr, 0.9, 0.3, 0.3);
|
||||
break;
|
||||
case 0:
|
||||
cairo_set_source_rgb (cr, 0.3, 0.9, 0.3);
|
||||
break;
|
||||
case 1:
|
||||
cairo_set_source_rgb (cr, 0.3, 0.3, 0.9);
|
||||
break;
|
||||
}
|
||||
|
||||
cairo_move_to (cr, 10, y);
|
||||
pango_cairo_show_layout (cr, layout);
|
||||
g_object_unref (layout);
|
||||
|
||||
y += height + 4;
|
||||
}
|
||||
}
|
||||
|
||||
static gboolean
|
||||
trap_view_expose (GtkWidget *w, GdkEventExpose *ev)
|
||||
{
|
||||
TrapView *self = (TrapView *) w;
|
||||
cairo_t *cr;
|
||||
|
||||
cr = gdk_cairo_create (w->window);
|
||||
gdk_cairo_region (cr, ev->region);
|
||||
cairo_clip (cr);
|
||||
|
||||
trap_view_draw (self, cr);
|
||||
trap_view_draw_labels (self, cr);
|
||||
|
||||
cairo_destroy (cr);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static gboolean
|
||||
trap_view_key_press (GtkWidget *w, GdkEventKey *ev)
|
||||
{
|
||||
switch (ev->keyval) {
|
||||
case GDK_Escape:
|
||||
case GDK_Q:
|
||||
gtk_main_quit ();
|
||||
break;
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static gboolean
|
||||
trap_view_button_press (GtkWidget *w, GdkEventButton *ev)
|
||||
{
|
||||
TrapView *self = (TrapView *) w;
|
||||
|
||||
if (ev->x < self->mag_x ||
|
||||
ev->y < self->mag_y ||
|
||||
ev->x > self->mag_x + self->mag_size ||
|
||||
ev->y > self->mag_y + self->mag_size)
|
||||
{
|
||||
}
|
||||
else
|
||||
{
|
||||
self->in_mag_drag = TRUE;
|
||||
self->mag_drag_x = ev->x;
|
||||
self->mag_drag_y = ev->y;
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static gboolean
|
||||
trap_view_button_release (GtkWidget *w, GdkEventButton *ev)
|
||||
{
|
||||
TrapView *self = (TrapView *) w;
|
||||
|
||||
self->in_mag_drag = FALSE;
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static void
|
||||
trap_view_update_mouse (TrapView *self, GdkEventMotion *ev)
|
||||
{
|
||||
self->px = ev->x;
|
||||
self->py = ev->y;
|
||||
|
||||
gtk_widget_queue_draw (&self->widget);
|
||||
}
|
||||
|
||||
static void
|
||||
trap_view_update_magnifier (TrapView *self, gint *xy)
|
||||
{
|
||||
self->mag_x = xy[0];
|
||||
self->mag_y = xy[1];
|
||||
|
||||
gtk_widget_queue_draw (&self->widget);
|
||||
}
|
||||
|
||||
static gboolean
|
||||
trap_view_motion (GtkWidget *w, GdkEventMotion *ev)
|
||||
{
|
||||
TrapView *self = (TrapView *) w;
|
||||
|
||||
if (self->in_mag_drag) {
|
||||
int xy[2];
|
||||
|
||||
xy[0] = self->mag_x + ev->x - self->mag_drag_x;
|
||||
xy[1] = self->mag_y + ev->y - self->mag_drag_y;
|
||||
|
||||
trap_view_update_magnifier (self, xy);
|
||||
|
||||
self->mag_drag_x = ev->x;
|
||||
self->mag_drag_y = ev->y;
|
||||
} else if (ev->x < self->mag_x ||
|
||||
ev->y < self->mag_y ||
|
||||
ev->x > self->mag_x + self->mag_size ||
|
||||
ev->y > self->mag_y + self->mag_size)
|
||||
{
|
||||
trap_view_update_mouse (self, ev);
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static void
|
||||
trap_view_realize (GtkWidget *widget)
|
||||
{
|
||||
GdkWindowAttr attributes;
|
||||
|
||||
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
|
||||
|
||||
attributes.window_type = GDK_WINDOW_CHILD;
|
||||
attributes.x = widget->allocation.x;
|
||||
attributes.y = widget->allocation.y;
|
||||
attributes.width = widget->allocation.width;
|
||||
attributes.height = widget->allocation.height;
|
||||
attributes.wclass = GDK_INPUT_OUTPUT;
|
||||
attributes.visual = gtk_widget_get_visual (widget);
|
||||
attributes.colormap = gtk_widget_get_colormap (widget);
|
||||
attributes.event_mask = gtk_widget_get_events (widget) |
|
||||
GDK_BUTTON_PRESS_MASK |
|
||||
GDK_BUTTON_RELEASE_MASK |
|
||||
GDK_KEY_PRESS_MASK |
|
||||
GDK_KEY_RELEASE_MASK |
|
||||
GDK_POINTER_MOTION_MASK |
|
||||
GDK_BUTTON_MOTION_MASK |
|
||||
GDK_EXPOSURE_MASK;
|
||||
|
||||
widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
|
||||
&attributes,
|
||||
GDK_WA_X | GDK_WA_Y |
|
||||
GDK_WA_VISUAL | GDK_WA_COLORMAP);
|
||||
gdk_window_set_user_data (widget->window, widget);
|
||||
|
||||
widget->style = gtk_style_attach (widget->style, widget->window);
|
||||
gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
|
||||
}
|
||||
|
||||
static void
|
||||
trap_view_size_allocate (GtkWidget *w, GdkRectangle *r)
|
||||
{
|
||||
TrapView *self = (TrapView *) w;
|
||||
|
||||
GTK_WIDGET_CLASS (trap_view_parent_class)->size_allocate (w, r);
|
||||
|
||||
self->mag_x = w->allocation.width - self->mag_size - 10;
|
||||
self->mag_y = w->allocation.height - self->mag_size - 10;
|
||||
}
|
||||
|
||||
static void
|
||||
trap_view_finalize (GObject *obj)
|
||||
{
|
||||
G_OBJECT_CLASS (trap_view_parent_class)->finalize (obj);
|
||||
}
|
||||
|
||||
static void
|
||||
trap_view_class_init (TrapViewClass *klass)
|
||||
{
|
||||
GObjectClass *object_class = (GObjectClass *) klass;
|
||||
GtkWidgetClass *widget_class = (GtkWidgetClass *) klass;
|
||||
|
||||
object_class->finalize = trap_view_finalize;
|
||||
|
||||
widget_class->realize = trap_view_realize;
|
||||
widget_class->size_allocate = trap_view_size_allocate;
|
||||
widget_class->expose_event = trap_view_expose;
|
||||
widget_class->key_press_event = trap_view_key_press;
|
||||
widget_class->button_press_event = trap_view_button_press;
|
||||
widget_class->button_release_event = trap_view_button_release;
|
||||
widget_class->motion_notify_event = trap_view_motion;
|
||||
}
|
||||
|
||||
static void
|
||||
trap_view_init (TrapView *self)
|
||||
{
|
||||
self->mag_zoom = 64;
|
||||
self->mag_size = 200;
|
||||
|
||||
self->extents.p1.x = G_MAXDOUBLE;
|
||||
self->extents.p1.y = G_MAXDOUBLE;
|
||||
self->extents.p2.x = -G_MAXDOUBLE;
|
||||
self->extents.p2.y = -G_MAXDOUBLE;
|
||||
|
||||
GTK_WIDGET_SET_FLAGS (self, GTK_CAN_FOCUS);
|
||||
}
|
||||
|
||||
static contour_t *
|
||||
_contour_add_point (TrapView *tv, contour_t *contour, point_t *p)
|
||||
{
|
||||
if (contour == NULL)
|
||||
return NULL;
|
||||
|
||||
if (p->y < tv->extents.p1.y)
|
||||
tv->extents.p1.y = p->y;
|
||||
if (p->y > tv->extents.p2.y)
|
||||
tv->extents.p2.y = p->y;
|
||||
|
||||
if (p->x < tv->extents.p1.x)
|
||||
tv->extents.p1.x = p->x;
|
||||
if (p->x > tv->extents.p2.x)
|
||||
tv->extents.p2.x = p->x;
|
||||
|
||||
if (contour->num_points == contour->size) {
|
||||
int newsize = 2 * contour->size;
|
||||
void *newcontour;
|
||||
|
||||
newcontour = g_realloc (contour,
|
||||
sizeof (contour_t) + newsize * sizeof (point_t));
|
||||
if (newcontour == NULL)
|
||||
return contour;
|
||||
|
||||
contour = newcontour;
|
||||
contour->size = newsize;
|
||||
|
||||
if (contour->next != NULL)
|
||||
contour->next->prev = newcontour;
|
||||
if (contour->prev != NULL)
|
||||
contour->prev->next = newcontour;
|
||||
else
|
||||
tv->contours = newcontour;
|
||||
}
|
||||
|
||||
contour->points[contour->num_points++] = *p;
|
||||
|
||||
return contour;
|
||||
}
|
||||
|
||||
static contour_t *
|
||||
contour_new (TrapView *tv, int direction)
|
||||
{
|
||||
contour_t *t;
|
||||
|
||||
t = g_malloc (sizeof (contour_t) + 128 * sizeof (point_t));
|
||||
t->direction = direction;
|
||||
t->prev = NULL;
|
||||
t->next = tv->contours;
|
||||
if (tv->contours)
|
||||
tv->contours->prev = t;
|
||||
tv->contours = t;
|
||||
|
||||
t->size = 128;
|
||||
t->num_points = 0;
|
||||
|
||||
return t;
|
||||
}
|
||||
|
||||
int
|
||||
main (int argc, char **argv)
|
||||
{
|
||||
TrapView *tv;
|
||||
contour_t *contour = NULL;
|
||||
GtkWidget *window;
|
||||
FILE *file;
|
||||
char *line = NULL;
|
||||
size_t len = 0;
|
||||
|
||||
gtk_init (&argc, &argv);
|
||||
|
||||
tv = g_object_new (trap_view_get_type (), NULL);
|
||||
|
||||
file = fopen (argv[1], "r");
|
||||
if (file != NULL) {
|
||||
while (getline (&line, &len, file) != -1) {
|
||||
point_t p;
|
||||
int direction;
|
||||
|
||||
if (sscanf (line, "contour: direction=%d", &direction)) {
|
||||
if (contour)
|
||||
g_print ("read %d contour\n", contour->num_points);
|
||||
|
||||
contour = contour_new (tv, direction);
|
||||
} else if (sscanf (line, " [%*d] = (%lf, %lf)", &p.x, &p.y) == 2) {
|
||||
contour = _contour_add_point (tv, contour, &p);
|
||||
}
|
||||
}
|
||||
|
||||
if (contour)
|
||||
g_print ("read %d contour\n", contour->num_points);
|
||||
|
||||
g_print ("extents=(%lg, %lg), (%lg, %lg)\n",
|
||||
tv->extents.p1.x, tv->extents.p1.y,
|
||||
tv->extents.p2.x, tv->extents.p2.y);
|
||||
fclose (file);
|
||||
}
|
||||
|
||||
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
|
||||
g_signal_connect (window, "delete-event",
|
||||
G_CALLBACK (gtk_main_quit), NULL);
|
||||
gtk_widget_set_size_request (window, 800, 800);
|
||||
gtk_container_add (GTK_CONTAINER (window), &tv->widget);
|
||||
gtk_widget_show_all (window);
|
||||
|
||||
gtk_main ();
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -202,6 +202,10 @@ polygon_view_draw (PolygonView *self, cairo_t *cr)
|
|||
else
|
||||
mag_x = self->px - size/4 - size;
|
||||
mag_y = self->py - size/2;
|
||||
if (mag_y < 0)
|
||||
mag_y = 0;
|
||||
if (mag_y + size > self->widget.allocation.height)
|
||||
mag_y = self->widget.allocation.height - size;
|
||||
}
|
||||
|
||||
cairo_save (cr); {
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue