diff options
Diffstat (limited to 'converter/other/pamtosvg')
| -rw-r--r-- | converter/other/pamtosvg/Makefile | 4 | ||||
| -rw-r--r-- | converter/other/pamtosvg/curve.c | 197 | ||||
| -rw-r--r-- | converter/other/pamtosvg/curve.h | 46 | ||||
| -rw-r--r-- | converter/other/pamtosvg/fit.c | 1870 | ||||
| -rw-r--r-- | converter/other/pamtosvg/pamtosvg.c | 4 | ||||
| -rw-r--r-- | converter/other/pamtosvg/pamtosvg.test | 6 | ||||
| -rw-r--r-- | converter/other/pamtosvg/pxl-outline.c | 45 | ||||
| -rw-r--r-- | converter/other/pamtosvg/spline.c | 10 | ||||
| -rw-r--r-- | converter/other/pamtosvg/spline.h | 1 | ||||
| -rw-r--r-- | converter/other/pamtosvg/vector.c | 282 | ||||
| -rw-r--r-- | converter/other/pamtosvg/vector.h | 70 |
11 files changed, 1404 insertions, 1131 deletions
diff --git a/converter/other/pamtosvg/Makefile b/converter/other/pamtosvg/Makefile index ba03fd68..8b033020 100644 --- a/converter/other/pamtosvg/Makefile +++ b/converter/other/pamtosvg/Makefile @@ -5,7 +5,7 @@ endif SUBDIR = converter/other/pamtosvg VPATH=.:$(SRCDIR)/$(SUBDIR) -include $(BUILDDIR)/Makefile.config +include $(BUILDDIR)/config.mk BINARIES = pamtosvg @@ -47,7 +47,7 @@ MERGEBINARIES = $(BINARIES) all: $(BINARIES) -include $(SRCDIR)/Makefile.common +include $(SRCDIR)/common.mk pamtosvg: $(PAMTOSVG_OBJECTS) $(NETPBMLIB) $(LIBOPT) $(LD) -o $@ $(PAMTOSVG_OBJECTS) \ diff --git a/converter/other/pamtosvg/curve.c b/converter/other/pamtosvg/curve.c index cc8aeb59..369a0cd3 100644 --- a/converter/other/pamtosvg/curve.c +++ b/converter/other/pamtosvg/curve.c @@ -42,18 +42,19 @@ int_to_real_coord(pm_pixelcoord const int_coord) { /* Return an entirely empty curve. */ -curve_type -new_curve (void) -{ - curve_type curve; - MALLOCVAR_NOFAIL(curve); - curve->point_list = NULL; - CURVE_LENGTH (curve) = 0; - CURVE_CYCLIC (curve) = false; - CURVE_START_TANGENT (curve) = CURVE_END_TANGENT (curve) = NULL; - PREVIOUS_CURVE (curve) = NEXT_CURVE (curve) = NULL; +curve * +new_curve(void) { + curve * curveP; - return curve; + MALLOCVAR_NOFAIL(curveP); + + curveP->point_list = NULL; + CURVE_LENGTH(curveP) = 0; + CURVE_CYCLIC(curveP) = false; + PREVIOUS_CURVE(curveP) = NULL; + NEXT_CURVE(curveP) = NULL; + + return curveP; } @@ -71,23 +72,39 @@ copy_most_of_curve (curve_type old_curve) return curve; } +void +move_curve(curve * const dstP, + curve * const srcP) { + + /* Move ownership of dynamically allocated memory from source + to destination; destroy source. + */ + + if (CURVE_LENGTH(dstP) > 0) + free(dstP->point_list); + + *dstP = *srcP; + + free(srcP); +} + + /* The length of CURVE will be zero if we ended up not being able to fit it (which in turn implies a problem elsewhere in the program, but at any rate, we shouldn't try here to free the nonexistent curve). */ void -free_curve (curve_type curve) -{ - if (CURVE_LENGTH (curve) > 0) - free (curve->point_list); - if (CURVE_START_TANGENT (curve)) - free (CURVE_START_TANGENT (curve)); - if (CURVE_END_TANGENT (curve)) - free (CURVE_END_TANGENT (curve)); +free_curve(curve * const curveP) { + + if (CURVE_LENGTH(curveP) > 0) + free(curveP->point_list); + + free(curveP); } + void append_point(curve_type const curve, float_coord const coord) { @@ -123,99 +140,84 @@ append_pixel(curve_type const curve, } \ while (0) + + void -log_curve (curve_type curve, bool print_t) -{ - unsigned this_point; - - if (!log_file) return; - - LOG1 ("curve id = %lx:\n", (unsigned long) curve); - LOG1 (" length = %u.\n", CURVE_LENGTH (curve)); - if (CURVE_CYCLIC (curve)) - LOG (" cyclic.\n"); - - /* It should suffice to check just one of the tangents for being null - -- either they both should be, or neither should be. */ - if (CURVE_START_TANGENT (curve) != NULL) - LOG4 (" tangents = (%.3f,%.3f) & (%.3f,%.3f).\n", - CURVE_START_TANGENT (curve)->dx, CURVE_START_TANGENT (curve)->dy, - CURVE_END_TANGENT (curve)->dx, CURVE_END_TANGENT (curve)->dy); - - LOG (" "); - - /* If the curve is short enough, don't use ellipses. */ - if (CURVE_LENGTH (curve) <= NUM_TO_PRINT * 2) - { - for (this_point = 0; this_point < CURVE_LENGTH (curve); this_point++) - { - LOG_CURVE_POINT (curve, this_point, print_t); - LOG (" "); - - if (this_point != CURVE_LENGTH (curve) - 1 - && (this_point + 1) % NUM_TO_PRINT == 0) - LOG ("\n "); +log_curve(curve * const curveP, + bool const print_t) { + + if (!log_file) + return; + + LOG1("curve id = %lx:\n", (unsigned long) curveP); + LOG1(" length = %u.\n", CURVE_LENGTH(curveP)); + if (CURVE_CYCLIC(curveP)) + LOG(" cyclic.\n"); + + LOG(" "); + + /* If the curve is short enough, don't use ellipses. */ + if (CURVE_LENGTH(curveP) <= NUM_TO_PRINT * 2) { + unsigned int thisPoint; + + for (thisPoint = 0; thisPoint < CURVE_LENGTH(curveP); ++thisPoint) { + LOG_CURVE_POINT(curveP, thisPoint, print_t); + LOG(" "); + + if (thisPoint != CURVE_LENGTH(curveP) - 1 + && (thisPoint + 1) % NUM_TO_PRINT == 0) + LOG("\n "); } - } - else - { - for (this_point = 0; - this_point < NUM_TO_PRINT && this_point < CURVE_LENGTH (curve); - this_point++) - { - LOG_CURVE_POINT (curve, this_point, print_t); - LOG (" "); + } else { + unsigned int thisPoint; + for (thisPoint = 0; + thisPoint < NUM_TO_PRINT && thisPoint < CURVE_LENGTH(curveP); + ++thisPoint) { + LOG_CURVE_POINT(curveP, thisPoint, print_t); + LOG(" "); } - LOG ("...\n ..."); + LOG("...\n ..."); - for (this_point = CURVE_LENGTH (curve) - NUM_TO_PRINT; - this_point < CURVE_LENGTH (curve); - this_point++) - { - LOG (" "); - LOG_CURVE_POINT (curve, this_point, print_t); + for (thisPoint = CURVE_LENGTH(curveP) - NUM_TO_PRINT; + thisPoint < CURVE_LENGTH(curveP); + ++thisPoint) { + LOG(" "); + LOG_CURVE_POINT(curveP, thisPoint, print_t); } } - - LOG (".\n"); + LOG(".\n"); } /* Like `log_curve', but write the whole thing. */ void -log_entire_curve (curve_type curve) -{ - unsigned this_point; +log_entire_curve(curve * const curveP) { - if (!log_file) return; + unsigned int thisPoint; - LOG1 ("curve id = %lx:\n", (unsigned long) curve); - LOG1 (" length = %u.\n", CURVE_LENGTH (curve)); - if (CURVE_CYCLIC (curve)) - LOG (" cyclic.\n"); + if (!log_file) + return; - /* It should suffice to check just one of the tangents for being null - -- either they both should be, or neither should be. */ - if (CURVE_START_TANGENT (curve) != NULL) - LOG4 (" tangents = (%.3f,%.3f) & (%.3f,%.3f).\n", - CURVE_START_TANGENT (curve)->dx, CURVE_START_TANGENT (curve)->dy, - CURVE_END_TANGENT (curve)->dx, CURVE_END_TANGENT (curve)->dy); + LOG1("curve id = %lx:\n", (unsigned long) curveP); + LOG1(" length = %u.\n", CURVE_LENGTH(curveP)); + if (CURVE_CYCLIC(curveP)) + LOG(" cyclic.\n"); - LOG (" "); + LOG(" "); - for (this_point = 0; this_point < CURVE_LENGTH (curve); this_point++) - { - LOG (" "); - LOG_CURVE_POINT (curve, this_point, true); - /* Compiler warning `Condition is always true' can be ignored */ + for (thisPoint = 0; thisPoint < CURVE_LENGTH(curveP); ++thisPoint) { + LOG(" "); + LOG_CURVE_POINT(curveP, thisPoint, true); + /* Compiler warning `Condition is always true' can be ignored */ } - LOG (".\n"); + LOG(".\n"); } + /* Return an initialized but empty curve list. */ curve_list_type @@ -233,19 +235,16 @@ new_curve_list (void) /* Free a curve list and all the curves it contains. */ void -free_curve_list(curve_list_type * const curve_list) { +free_curve_list(curve_list_type * const curveListP) { - unsigned this_curve; + unsigned int thisCurve; - for (this_curve = 0; this_curve < curve_list->length; this_curve++) - { - free_curve (curve_list->data[this_curve]); - free (curve_list->data[this_curve]); - } + for (thisCurve = 0; thisCurve < curveListP->length; ++thisCurve) + free_curve(curveListP->data[thisCurve]); - /* If the character was empty, it won't have any curves. */ - if (curve_list->data != NULL) - free (curve_list->data); + /* If the character was empty, it won't have any curves. */ + if (curveListP->data != NULL) + free (curveListP->data); } diff --git a/converter/other/pamtosvg/curve.h b/converter/other/pamtosvg/curve.h index ee046620..ba5f1833 100644 --- a/converter/other/pamtosvg/curve.h +++ b/converter/other/pamtosvg/curve.h @@ -20,19 +20,27 @@ typedef struct { -struct curve { +typedef struct curve { /*---------------------------------------------------------------------------- An ordered list of contiguous points in the raster, with no corners in it. I.e. something that could reasonably be fit to a spline. -----------------------------------------------------------------------------*/ point_type * point_list; + /* Array of the points in the curve. Malloc'ed. Size is 'length'. + if 'length' is zero, this is meaningless and no memory is + allocated. + */ unsigned length; + /* Number of points in the curve */ bool cyclic; - vector_type * start_tangent; - vector_type * end_tangent; + + /* 'previous' and 'next' links are for the doubly linked list which is + a chain of all curves in an outline. The chain is a cycle for a + closed outline and linear for an open outline. + */ struct curve * previous; struct curve * next; -}; +} curve; typedef struct curve * curve_type; @@ -61,9 +69,6 @@ typedef struct curve * curve_type; ? CURVE_CYCLIC (c) ? (signed int) CURVE_LENGTH (c) + (signed int) (n) - 1 : -1\ : (signed int) (n) - 1) -/* The tangents at the endpoints are computed using the neighboring curves. */ -#define CURVE_START_TANGENT(c) ((c)->start_tangent) -#define CURVE_END_TANGENT(c) ((c)->end_tangent) #define PREVIOUS_CURVE(c) ((c)->previous) #define NEXT_CURVE(c) ((c)->next) @@ -74,17 +79,23 @@ extern curve_type new_curve (void); /* Return a curve the same as C, except without any points. */ extern curve_type copy_most_of_curve (curve_type c); -/* Free the memory C uses. */ -extern void free_curve (curve_type c); +void +move_curve(curve * const dstP, + curve * const srcP); + +void +free_curve(curve * const curveP); + +/* Like `append_pixel', for a point in real coordinates. */ +void +append_point(curve_type const curve, + float_coord const coord); /* Append the point P to the end of C's list. */ void append_pixel(curve_type const c, pm_pixelcoord const p); -/* Like `append_pixel', for a point in real coordinates. */ -extern void append_point (curve_type const c, float_coord const p); - /* Write some or all, respectively, of the curve C in human-readable form to the log file, if logging is enabled. */ extern void log_curve (curve_type c, bool print_t); @@ -99,11 +110,12 @@ typedef struct { /*---------------------------------------------------------------------------- An ordered list of contiguous curves of a particular color. -----------------------------------------------------------------------------*/ - curve_type * data; - unsigned length; - bool clockwise; - pixel color; - bool open; + curve ** data; + /* data[i] is the handle of the ith curve in the list */ + unsigned length; + bool clockwise; + pixel color; + bool open; /* The curve list does not form a closed shape; i.e. the last curve doesn't end where the first one starts. */ diff --git a/converter/other/pamtosvg/fit.c b/converter/other/pamtosvg/fit.c index 6bc2fe88..5ba7a2f6 100644 --- a/converter/other/pamtosvg/fit.c +++ b/converter/other/pamtosvg/fit.c @@ -54,21 +54,7 @@ typedef struct index_list #define INDEX_LIST_LENGTH(i_l) ((i_l).length) #define GET_LAST_INDEX(i_l) ((i_l).data[INDEX_LIST_LENGTH (i_l) - 1]) -static void append_index (index_list_type *, unsigned); -static void free_index_list (index_list_type *); -static index_list_type new_index_list (void); -static void remove_adjacent_corners (index_list_type *, unsigned, bool, - at_exception_type * exception); -static void filter (curve_type, fitting_opts_type *); -static void find_vectors - (unsigned const, pixel_outline_type const, vector_type * const, vector_type * const, unsigned const); -static float find_error (curve_type, spline_type, unsigned *, - at_exception_type * exception); -static vector_type find_half_tangent (curve_type, bool start, unsigned *, unsigned); -static void find_tangent (curve_type, bool, bool, unsigned); -static void remove_knee_points (curve_type const, bool const); -static void set_initial_parameter_values (curve_type); -static float distance (float_coord, float_coord); + static pm_pixelcoord @@ -86,6 +72,50 @@ real_to_int_coord(float_coord const real_coord) { } +/* Lists of array indices (well, that is what we use it for). */ + +static index_list_type +new_index_list (void) +{ + index_list_type index_list; + + index_list.data = NULL; + INDEX_LIST_LENGTH (index_list) = 0; + + return index_list; +} + +static void +free_index_list (index_list_type *index_list) +{ + if (INDEX_LIST_LENGTH (*index_list) > 0) + { + free (index_list->data); + index_list->data = NULL; + INDEX_LIST_LENGTH (*index_list) = 0; + } +} + +static void +append_index (index_list_type *list, unsigned new_index) +{ + INDEX_LIST_LENGTH (*list)++; + REALLOCARRAY_NOFAIL(list->data, INDEX_LIST_LENGTH(*list)); + list->data[INDEX_LIST_LENGTH (*list) - 1] = new_index; +} + + +/* Return the Euclidean distance between P1 and P2. */ + +static float +distance (float_coord p1, float_coord p2) +{ + float x = p1.x - p2.x, y = p1.y - p2.y, z = p1.z - p2.z; + return (float) sqrt (SQR(x) + SQR(y) + SQR(z)); +} + + + static void appendCorner(index_list_type * const cornerListP, unsigned int const pixelSeq, @@ -102,6 +132,45 @@ appendCorner(index_list_type * const cornerListP, static void +find_vectors(unsigned int const test_index, + pixel_outline_type const outline, + vector_type * const in, + vector_type * const out, + unsigned int const corner_surround) { +/*---------------------------------------------------------------------------- + Return the difference vectors coming in and going out of the outline + OUTLINE at the point whose index is TEST_INDEX. In Phoenix, + Schneider looks at a single point on either side of the point we're + considering. That works for him because his points are not touching. + But our points *are* touching, and so we have to look at + `corner_surround' points on either side, to get a better picture of + the outline's shape. +-----------------------------------------------------------------------------*/ + int i; + unsigned n_done; + pm_pixelcoord const candidate = O_COORDINATE(outline, test_index); + + in->dx = in->dy = in->dz = 0.0; + out->dx = out->dy = out->dz = 0.0; + + /* Add up the differences from p of the `corner_surround' points + before p. + */ + for (i = O_PREV(outline, test_index), n_done = 0; + n_done < corner_surround; + i = O_PREV(outline, i), ++n_done) + *in = Vadd(*in, IPsubtract(O_COORDINATE(outline, i), candidate)); + + /* And the points after p. */ + for (i = O_NEXT (outline, test_index), n_done = 0; + n_done < corner_surround; + i = O_NEXT(outline, i), ++n_done) + *out = Vadd(*out, IPsubtract(O_COORDINATE(outline, i), candidate)); +} + + + +static void lookAheadForBetterCorner(pixel_outline_type const outline, unsigned int const basePixelSeq, float const baseCornerAngle, @@ -210,6 +279,283 @@ establishCornerSearchLimits(pixel_outline_type const outline, static void +remove_adjacent_corners(index_list_type * const list, + unsigned int const last_index, + bool const remove_adj_corners, + at_exception_type * const exception) { +/*---------------------------------------------------------------------------- + Remove adjacent points from the index list LIST. We do this by first + sorting the list and then running through it. Since these lists are + quite short, a straight selection sort (e.g., p.139 of the Art of + Computer Programming, vol.3) is good enough. LAST_INDEX is the index + of the last pixel on the outline, i.e., the next one is the first + pixel. We need this for checking the adjacency of the last corner. + + We need to do this because the adjacent corners turn into + two-pixel-long curves, which can be fit only by straight lines. +-----------------------------------------------------------------------------*/ + unsigned int j; + unsigned int last; + index_list_type new_list = new_index_list (); + + for (j = INDEX_LIST_LENGTH (*list) - 1; j > 0; j--) + { + unsigned search; + unsigned temp; + /* Find maximal element below `j'. */ + unsigned max_index = j; + + for (search = 0; search < j; search++) + if (GET_INDEX (*list, search) > GET_INDEX (*list, max_index)) + max_index = search; + + if (max_index != j) + { + temp = GET_INDEX (*list, j); + GET_INDEX (*list, j) = GET_INDEX (*list, max_index); + GET_INDEX (*list, max_index) = temp; + } + } + + /* The list is sorted. Now look for adjacent entries. Each time + through the loop we insert the current entry and, if appropriate, + the next entry. */ + for (j = 0; j < INDEX_LIST_LENGTH (*list) - 1; j++) + { + unsigned current = GET_INDEX (*list, j); + unsigned next = GET_INDEX (*list, j + 1); + + /* We should never have inserted the same element twice. */ + /* assert (current != next); */ + + if ((remove_adj_corners) && ((next == current + 1) || (next == current))) + j++; + + append_index (&new_list, current); + } + + /* Don't append the last element if it is 1) adjacent to the previous + one; or 2) adjacent to the very first one. */ + last = GET_LAST_INDEX (*list); + if (INDEX_LIST_LENGTH (new_list) == 0 + || !(last == GET_LAST_INDEX (new_list) + 1 + || (last == last_index && GET_INDEX (*list, 0) == 0))) + append_index (&new_list, last); + + free_index_list (list); + *list = new_list; +} + +/* A ``knee'' is a point which forms a ``right angle'' with its + predecessor and successor. See the documentation (the `Removing + knees' section) for an example and more details. + + The argument CLOCKWISE tells us which direction we're moving. (We + can't figure that information out from just the single segment with + which we are given to work.) + + We should never find two consecutive knees. + + Since the first and last points are corners (unless the curve is + cyclic), it doesn't make sense to remove those. +*/ + +/* This evaluates to true if the vector V is zero in one direction and + nonzero in the other. */ +#define ONLY_ONE_ZERO(v) \ + (((v).dx == 0.0 && (v).dy != 0.0) || ((v).dy == 0.0 && (v).dx != 0.0)) + +/* There are four possible cases for knees, one for each of the four + corners of a rectangle; and then the cases differ depending on which + direction we are going around the curve. The tests are listed here + in the order of upper left, upper right, lower right, lower left. + Perhaps there is some simple pattern to the + clockwise/counterclockwise differences, but I don't see one. */ +#define CLOCKWISE_KNEE(prev_delta, next_delta) \ + ((prev_delta.dx == -1.0 && next_delta.dy == 1.0) \ + || (prev_delta.dy == 1.0 && next_delta.dx == 1.0) \ + || (prev_delta.dx == 1.0 && next_delta.dy == -1.0) \ + || (prev_delta.dy == -1.0 && next_delta.dx == -1.0)) + +#define COUNTERCLOCKWISE_KNEE(prev_delta, next_delta) \ + ((prev_delta.dy == 1.0 && next_delta.dx == -1.0) \ + || (prev_delta.dx == 1.0 && next_delta.dy == 1.0) \ + || (prev_delta.dy == -1.0 && next_delta.dx == 1.0) \ + || (prev_delta.dx == -1.0 && next_delta.dy == -1.0)) + + + +static void +remove_knee_points(curve * const curveP, + bool const clockwise) { + + unsigned int const offset = CURVE_CYCLIC(curveP) ? 0 : 1; + curve * const trimmedCurveP = copy_most_of_curve(curveP); + + pm_pixelcoord previous; + unsigned int i; + + if (!CURVE_CYCLIC(curveP)) + append_pixel(trimmedCurveP, + real_to_int_coord(CURVE_POINT(curveP, 0))); + + previous = real_to_int_coord(CURVE_POINT(curveP, + CURVE_PREV(curveP, offset))); + + for (i = offset; i < CURVE_LENGTH(curveP) - offset; ++i) { + pm_pixelcoord const current = + real_to_int_coord(CURVE_POINT(curveP, i)); + pm_pixelcoord const next = + real_to_int_coord(CURVE_POINT(curveP, CURVE_NEXT(curveP, i))); + vector_type const prev_delta = IPsubtract(previous, current); + vector_type const next_delta = IPsubtract(next, current); + + if (ONLY_ONE_ZERO(prev_delta) && ONLY_ONE_ZERO(next_delta) + && ((clockwise && CLOCKWISE_KNEE(prev_delta, next_delta)) + || (!clockwise + && COUNTERCLOCKWISE_KNEE(prev_delta, next_delta)))) + LOG2(" (%d,%d)", current.col, current.row); + else { + previous = current; + append_pixel(trimmedCurveP, current); + } + } + + if (!CURVE_CYCLIC(curveP)) + append_pixel(trimmedCurveP, + real_to_int_coord(LAST_CURVE_POINT(curveP))); + + if (CURVE_LENGTH(trimmedCurveP) == CURVE_LENGTH(curveP)) + LOG(" (none)"); + + LOG(".\n"); + + move_curve(curveP, trimmedCurveP); +} + + + +static void +filter(curve * const curveP, + fitting_opts_type * const fittingOptsP) { +/*---------------------------------------------------------------------------- + Smooth the curve by adding in neighboring points. Do this + fittingOptsP->filter_iterations times. But don't change the corners. +-----------------------------------------------------------------------------*/ + unsigned int const offset = CURVE_CYCLIC(curveP) ? 0 : 1; + + unsigned int iteration, thisPoint; + float_coord prevNewPoint; + + /* We must have at least three points -- the previous one, the current + one, and the next one. But if we don't have at least five, we will + probably collapse the curve down onto a single point, which means + we won't be able to fit it with a spline. + */ + if (CURVE_LENGTH(curveP) < 5) { + LOG1("Length is %u, not enough to filter.\n", CURVE_LENGTH(curveP)); + return; + } + + prevNewPoint.x = FLT_MAX; + prevNewPoint.y = FLT_MAX; + prevNewPoint.z = FLT_MAX; + + for (iteration = 0; + iteration < fittingOptsP->filter_iterations; + ++iteration) { + curve * const newcurveP = copy_most_of_curve(curveP); + + bool collapsed; + + collapsed = false; /* initial value */ + + /* Keep the first point on the curve. */ + if (offset) + append_point(newcurveP, CURVE_POINT(curveP, 0)); + + for (thisPoint = offset; + thisPoint < CURVE_LENGTH(curveP) - offset; + ++thisPoint) { + vector_type in, out, sum; + float_coord newPoint; + + /* Calculate the vectors in and out, computed by looking + at n points on either side of this_point. Experimental + it was found that 2 is optimal. + */ + + signed int prev, prevprev; /* have to be signed */ + unsigned int next, nextnext; + float_coord candidate = CURVE_POINT(curveP, thisPoint); + + prev = CURVE_PREV(curveP, thisPoint); + prevprev = CURVE_PREV(curveP, prev); + next = CURVE_NEXT(curveP, thisPoint); + nextnext = CURVE_NEXT(curveP, next); + + /* Add up the differences from p of the `surround' points + before p. + */ + in.dx = in.dy = in.dz = 0.0; + + in = Vadd(in, Psubtract(CURVE_POINT(curveP, prev), candidate)); + if (prevprev >= 0) + in = Vadd(in, + Psubtract(CURVE_POINT(curveP, prevprev), candidate)); + + /* And the points after p. Don't use more points after p than we + ended up with before it. + */ + out.dx = out.dy = out.dz = 0.0; + + out = Vadd(out, Psubtract(CURVE_POINT(curveP, next), candidate)); + if (nextnext < CURVE_LENGTH(curveP)) + out = Vadd(out, + Psubtract(CURVE_POINT(curveP, nextnext), + candidate)); + + /* Start with the old point. */ + newPoint = candidate; + sum = Vadd(in, out); + /* We added 2*n+2 points, so we have to divide the sum by 2*n+2 */ + newPoint.x += sum.dx / 6; + newPoint.y += sum.dy / 6; + newPoint.z += sum.dz / 6; + if (fabs(prevNewPoint.x - newPoint.x) < 0.3 + && fabs (prevNewPoint.y - newPoint.y) < 0.3 + && fabs (prevNewPoint.z - newPoint.z) < 0.3) { + collapsed = true; + break; + } + + /* Put the newly computed point into a separate curve, so it + doesn't affect future computation (on this iteration). + */ + append_point(newcurveP, prevNewPoint = newPoint); + } + + if (collapsed) + free_curve(newcurveP); + else { + /* Just as with the first point, we have to keep the last + point. + */ + if (offset) + append_point(newcurveP, LAST_CURVE_POINT(curveP)); + + /* Set the original curve to the newly filtered one, and go + again. + */ + move_curve(curveP, newcurveP); + } + } + log_curve(curveP, false); +} + + + +static void removeAdjacent(index_list_type * const cornerListP, pixel_outline_type const outline, fitting_opts_type * const fittingOptsP, @@ -340,25 +686,27 @@ makeOutlineOneCurve(pixel_outline_type const outline, curve_list_type * const curveListP) { /*---------------------------------------------------------------------------- Add to *curveListP a single curve that represents the outline 'outline'. + + That curve does not have beginning and ending slope information. -----------------------------------------------------------------------------*/ - curve_type curve; + curve * curveP; unsigned int pixelSeq; - curve = new_curve(); - + curveP = new_curve(); + for (pixelSeq = 0; pixelSeq < O_LENGTH(outline); ++pixelSeq) - append_pixel(curve, O_COORDINATE(outline, pixelSeq)); + append_pixel(curveP, O_COORDINATE(outline, pixelSeq)); - if (curveListP->open) - CURVE_CYCLIC(curve) = false; + if (outline.open) + CURVE_CYCLIC(curveP) = false; else - CURVE_CYCLIC(curve) = true; + CURVE_CYCLIC(curveP) = true; /* Make it a one-curve cycle */ - NEXT_CURVE(curve) = curve; - PREVIOUS_CURVE(curve) = curve; + NEXT_CURVE(curveP) = curveP; + PREVIOUS_CURVE(curveP) = curveP; - append_curve(curveListP, curve); + append_curve(curveListP, curveP); } @@ -367,12 +715,22 @@ static void addCurveStartingAtCorner(pixel_outline_type const outline, index_list_type const cornerList, unsigned int const cornerSeq, - curve_list_type * const curveListP) { + curve_list_type * const curveListP, + curve ** const curCurvePP) { +/*---------------------------------------------------------------------------- + Add to the list *curveListP a new curve that starts at the cornerSeq'th + corner in outline 'outline' (whose corners are 'cornerList') and + goes to the next corner (or the end of the outline if no next corner). + + Furthermore, add that curve to the curve chain whose end is pointed + to by *curCurvePP (NULL means chain is empty). + Don't include beginning and ending slope information for that curve. +-----------------------------------------------------------------------------*/ unsigned int const cornerPixelSeq = GET_INDEX(cornerList, cornerSeq); unsigned int lastPixelSeq; - curve_type curve; + curve * curveP; unsigned int pixelSeq; if (cornerSeq + 1 >= cornerList.length) @@ -382,20 +740,23 @@ addCurveStartingAtCorner(pixel_outline_type const outline, /* Go through the next corner */ lastPixelSeq = GET_INDEX(cornerList, cornerSeq + 1); - curve = new_curve(); + curveP = new_curve(); for (pixelSeq = cornerPixelSeq; pixelSeq <= lastPixelSeq; ++pixelSeq) - append_pixel(curve, O_COORDINATE(outline, pixelSeq)); + append_pixel(curveP, O_COORDINATE(outline, pixelSeq)); + append_curve(curveListP, curveP); { - /* Add curve to end of chain */ - if (!CURVE_LIST_EMPTY(*curveListP)) { - curve_type const previousCurve = LAST_CURVE_LIST_ELT(*curveListP); - NEXT_CURVE(previousCurve) = curve; - PREVIOUS_CURVE(curve) = previousCurve; + /* Add the new curve to the outline chain */ + + curve * const oldCurCurveP = *curCurvePP; + + if (oldCurCurveP) { + NEXT_CURVE(oldCurCurveP) = curveP; + PREVIOUS_CURVE(curveP) = oldCurCurveP; } + *curCurvePP = curveP; } - append_curve(curveListP, curve); } @@ -421,53 +782,60 @@ divideOutlineWithCorners(pixel_outline_type const outline, corner). Assume there is at least one corner. + + The curves do not have beginning and ending slope information. -----------------------------------------------------------------------------*/ unsigned int const firstCurveSeq = CURVE_LIST_LENGTH(*curveListP); /* Index in curve list of the first curve we add */ unsigned int cornerSeq; + curve * curCurveP; + /* Pointer to the curve we most recently added for this outline. + Null if none + */ assert(cornerList.length > 0); + curCurveP = NULL; /* No curves in outline chain yet */ + if (outline.open) { - /* Start with a curve that contains the point up to the first + /* Start with a curve that contains the points up to the first corner */ - curve_type curve; + curve * curveP; unsigned int pixelSeq; - curve = new_curve(); + curveP = new_curve(); for (pixelSeq = 0; pixelSeq <= GET_INDEX(cornerList, 0); ++pixelSeq) - append_pixel(curve, O_COORDINATE(outline, pixelSeq)); + append_pixel(curveP, O_COORDINATE(outline, pixelSeq)); - append_curve(curveListP, curve); - } else + append_curve(curveListP, curveP); + curCurveP = curveP; /* Only curve in outline chain now */ + } else { /* We'll pick up the pixels before the first corner at the end */ - + } /* Add to the list a curve that starts at each corner and goes through the following corner, or the end of the outline if there is no following corner. Do it in order of the corners. */ for (cornerSeq = 0; cornerSeq < cornerList.length; ++cornerSeq) - addCurveStartingAtCorner(outline, cornerList, cornerSeq, curveListP); + addCurveStartingAtCorner(outline, cornerList, cornerSeq, curveListP, + &curCurveP); if (!outline.open) { /* Come around to the start of the curve list -- add the pixels before the first corner to the last curve, and chain the last curve to the first one. */ - curve_type const firstCurve = - CURVE_LIST_ELT(*curveListP, firstCurveSeq); - curve_type const lastCurve = - LAST_CURVE_LIST_ELT(*curveListP); + curve * const firstCurveP = CURVE_LIST_ELT(*curveListP, firstCurveSeq); unsigned int pixelSeq; for (pixelSeq = 0; pixelSeq <= GET_INDEX(cornerList, 0); ++pixelSeq) - append_pixel(lastCurve, O_COORDINATE(outline, pixelSeq)); + append_pixel(curCurveP, O_COORDINATE(outline, pixelSeq)); - NEXT_CURVE(lastCurve) = firstCurve; - PREVIOUS_CURVE(firstCurve) = lastCurve; + NEXT_CURVE(curCurveP) = firstCurveP; + PREVIOUS_CURVE(firstCurveP) = curCurveP; } } @@ -501,6 +869,9 @@ split_at_corners(pixel_outline_list_type const pixel_list, To preserve this information, we return an array of curve_lists, one element (which in turn consists of several curves, one between each pair of corners) for each element in PIXEL_LIST. + + The curves we return do not have beginning and ending slope + information. -----------------------------------------------------------------------------*/ unsigned outlineSeq; curve_list_array_type curve_array; @@ -797,27 +1168,30 @@ spline_linear_enough(spline_type * const spline, /* Forward declaration for recursion */ static spline_list_type * -fitCurve(curve_type const curve, - const fitting_opts_type * const fitting_opts, - at_exception_type * const exception); +fitCurve(curve * const curveP, + vector_type const begSlope, + vector_type const endSlope, + const fitting_opts_type * const fittingOptsP, + at_exception_type * const exceptionP); static spline_list_type * -fit_with_line(curve_type const curve) { +fitWithLine(curve * const curveP) { /*---------------------------------------------------------------------------- - This routine returns the curve fitted to a straight line in a very - simple way: make the first and last points on the curve be the - endpoints of the line. This simplicity is justified because we are - called only on very short curves. + Return a list of splines that fit curve *curveP in a very simple way: + a single spline which is a straight line through the first and last + points on the curve. + + This simplicity is useful only on a very short curve. -----------------------------------------------------------------------------*/ spline_type line; LOG("Fitting with straight line:\n"); SPLINE_DEGREE(line) = LINEARTYPE; - START_POINT(line) = CONTROL1(line) = CURVE_POINT(curve, 0); - END_POINT(line) = CONTROL2(line) = LAST_CURVE_POINT(curve); + START_POINT(line) = CONTROL1(line) = CURVE_POINT(curveP, 0); + END_POINT(line) = CONTROL2(line) = LAST_CURVE_POINT(curveP); /* Make sure that this line is never changed to a cubic. */ SPLINE_LINEARITY(line) = 0; @@ -838,98 +1212,123 @@ fit_with_line(curve_type const curve) { #define B3(t) CUBE (t) static spline_type -fit_one_spline(curve_type const curve, - at_exception_type * const exception) { +fitOneSpline(curve * const curveP, + vector_type const begSlope, + vector_type const endSlope, + at_exception_type * const exceptionP) { /*---------------------------------------------------------------------------- - Our job here is to find alpha1 (and alpha2), where t1_hat (t2_hat) is - the tangent to CURVE at the starting (ending) point, such that: + Return a spline that fits the points of curve *curveP, + with slope 'begSlope' at its beginning and 'endSlope' at its end. - control1 = alpha1 * t1_hat + starting point - control2 = alpha2 * t2_hat + ending_point + Make it a cubic spline. +-----------------------------------------------------------------------------*/ + /* We already have the start and end points of the spline, so all + we need are the control points. And we know in what direction + each control point is from its respective end point, so all we + need to figure out is its distance. (The control point's + distance from the end point is an indication of how long the + curve goes in its direction). - and the resulting spline (starting_point .. control1 and control2 .. - ending_point) minimizes the least-square error from CURVE. + We call the distance from an end point to the associated control + point "alpha". - See pp.57--59 of the Phoenix thesis. + We want to find starting and ending alpha that minimize the + least-square error in approximating *curveP with the spline. + + How we do that is a complete mystery to me, but the original author + said to see pp.57--59 of the Phoenix thesis. I haven't seen that. + + In our expression of the math here, we use a struct with "beg" and + "end" members where the paper uses a matrix with "1" and "2" + subscripts, respectively. A C array is a closer match to a math + matrix, but we think the struct is easier to read. + + The B?(t) here corresponds to B_i^3(U_i) there. + The Bernstein polynomials of degree n are defined by + B_i^n(t) = { n \choose i } t^i (1-t)^{n-i}, i = 0..n - The B?(t) here corresponds to B_i^3(U_i) there. - The Bernshte\u in polynomials of degree n are defined by - B_i^n(t) = { n \choose i } t^i (1-t)^{n-i}, i = 0..n ------------------------------------------------------------------------------*/ - /* Since our arrays are zero-based, the `C0' and `C1' here correspond - to `C1' and `C2' in the paper. */ - float X_C1_det, C0_X_det, C0_C1_det; - float alpha1, alpha2; + struct vectorPair { + vector_type beg; + vector_type end; + }; + struct vectorPair tang; + + float X_Cend_det, Cbeg_X_det, C_det; spline_type spline; - vector_type start_vector, end_vector; + vector_type begVector, endVector; unsigned i; - vector_type * A; - vector_type t1_hat; - vector_type t2_hat; - float C[2][2] = { { 0.0, 0.0 }, { 0.0, 0.0 } }; - float X[2] = { 0.0, 0.0 }; + struct vectorPair * A; /* malloc'ed array */ + /* I don't know the meaning of this array, but it is one entry for + each point in the curve (A[i] is for the ith point in the curve). + */ + struct { + struct { float beg; float end; } beg; + struct { float beg; float end; } end; + } C; + struct { float beg; float end; } X; - t1_hat = *CURVE_START_TANGENT(curve); /* initial value */ - t2_hat = *CURVE_END_TANGENT(curve); /* initial value */ + tang.beg = begSlope; tang.end = endSlope; - MALLOCARRAY_NOFAIL(A, CURVE_LENGTH(curve) * 2); + MALLOCARRAY_NOFAIL(A, CURVE_LENGTH(curveP)); - START_POINT(spline) = CURVE_POINT(curve, 0); - END_POINT(spline) = LAST_CURVE_POINT(curve); - start_vector = make_vector(START_POINT(spline)); - end_vector = make_vector(END_POINT(spline)); + BEG_POINT(spline) = CURVE_POINT(curveP, 0); + END_POINT(spline) = LAST_CURVE_POINT(curveP); + begVector = make_vector(BEG_POINT(spline)); + endVector = make_vector(END_POINT(spline)); - for (i = 0; i < CURVE_LENGTH(curve); ++i) { - A[(i << 1) + 0] = Vmult_scalar(t1_hat, B1(CURVE_T(curve, i))); - A[(i << 1) + 1] = Vmult_scalar(t2_hat, B2(CURVE_T(curve, i))); + for (i = 0; i < CURVE_LENGTH(curveP); ++i) { + A[i].beg = Vmult_scalar(tang.beg, B1(CURVE_T(curveP, i))); + A[i].end = Vmult_scalar(tang.end, B2(CURVE_T(curveP, i))); } - for (i = 0; i < CURVE_LENGTH(curve); ++i) { + C.beg.beg = 0.0; C.beg.end = 0.0; C.end.end = 0.0; /* initial value */ + + X.beg = 0.0; X.end = 0.0; /* initial value */ + + for (i = 0; i < CURVE_LENGTH(curveP); ++i) { + struct vectorPair * const AP = &A[i]; vector_type temp, temp0, temp1, temp2, temp3; - vector_type * Ai = A + (i << 1); - C[0][0] += Vdot(Ai[0], Ai[0]); - C[0][1] += Vdot(Ai[0], Ai[1]); - /* C[1][0] = C[0][1] (this is assigned outside the loop) */ - C[1][1] += Vdot(Ai[1], Ai[1]); + C.beg.beg += Vdot(AP->beg, AP->beg); + C.beg.end += Vdot(AP->beg, AP->end); + /* C.end.beg = Vdot(AP->end, AP->beg) is done outside of loop */ + C.end.end += Vdot(AP->end, AP->end); /* Now the right-hand side of the equation in the paper. */ - temp0 = Vmult_scalar(start_vector, B0(CURVE_T(curve, i))); - temp1 = Vmult_scalar(start_vector, B1(CURVE_T(curve, i))); - temp2 = Vmult_scalar(end_vector, B2(CURVE_T(curve, i))); - temp3 = Vmult_scalar(end_vector, B3(CURVE_T(curve, i))); + temp0 = Vmult_scalar(begVector, B0(CURVE_T(curveP, i))); + temp1 = Vmult_scalar(begVector, B1(CURVE_T(curveP, i))); + temp2 = Vmult_scalar(endVector, B2(CURVE_T(curveP, i))); + temp3 = Vmult_scalar(endVector, B3(CURVE_T(curveP, i))); temp = make_vector( - Vsubtract_point(CURVE_POINT(curve, i), + Vsubtract_point(CURVE_POINT(curveP, i), Vadd(temp0, Vadd(temp1, Vadd(temp2, temp3))))); - X[0] += Vdot(temp, Ai[0]); - X[1] += Vdot(temp, Ai[1]); + X.beg += Vdot(temp, AP->beg); + X.end += Vdot(temp, AP->end); } free(A); - C[1][0] = C[0][1]; + C.end.beg = C.beg.end; - X_C1_det = X[0] * C[1][1] - X[1] * C[0][1]; - C0_X_det = C[0][0] * X[1] - C[0][1] * X[0]; - C0_C1_det = C[0][0] * C[1][1] - C[1][0] * C[0][1]; - if (C0_C1_det == 0.0) { - LOG ("zero determinant of C0*C1"); - at_exception_fatal(exception, "zero determinant of C0*C1"); - goto cleanup; - } - - alpha1 = X_C1_det / C0_C1_det; - alpha2 = C0_X_det / C0_C1_det; - - CONTROL1(spline) = Vadd_point(START_POINT(spline), - Vmult_scalar(t1_hat, alpha1)); - CONTROL2(spline) = Vadd_point(END_POINT(spline), - Vmult_scalar(t2_hat, alpha2)); - SPLINE_DEGREE(spline) = CUBICTYPE; - -cleanup: + X_Cend_det = X.beg * C.end.end - X.end * C.beg.end; + Cbeg_X_det = C.beg.beg * X.end - C.beg.end * X.beg; + C_det = C.beg.beg * C.end.end - C.end.beg * C.beg.end; + if (C_det == 0.0) { + LOG("zero determinant of C matrix"); + at_exception_fatal(exceptionP, "zero determinant of C matrix"); + } else { + struct { float beg; float end; } alpha; /* constant */ + alpha.beg = X_Cend_det / C_det; + alpha.end = Cbeg_X_det / C_det; + + CONTROL1(spline) = Vadd_point(BEG_POINT(spline), + Vmult_scalar(tang.beg, alpha.beg)); + CONTROL2(spline) = Vadd_point(END_POINT(spline), + Vmult_scalar(tang.end, alpha.end)); + SPLINE_DEGREE(spline) = CUBICTYPE; + } return spline; } @@ -951,214 +1350,538 @@ logSplineFit(spline_type const spline) { -static spline_list_type * -fit_with_least_squares(curve_type const curve, - const fitting_opts_type * const fitting_opts, - at_exception_type * const exception) { +static vector_type +findHalfTangentBeg(curve * const curveP, + unsigned int const tangentSurround) { /*---------------------------------------------------------------------------- - The least squares method is well described in Schneider's thesis. - Briefly, we try to fit the entire curve with one spline. If that - fails, we subdivide the curve. + Find the slope in the vicinity of the beginning of the curve + *curveP. + + To wit, this is the mean slope between the first point on the curve and + each of the 'tangentSurround' following points, up to half the curve. + + For example, if 'tangentSurround' is 3 and the curve is 10 points + long, we imagine a line through Point 0 and Point 1, another through + Point 0 and Point 2, and a third through Point 0 and Point 3. We + return the mean of the slopes of those 3 lines. -----------------------------------------------------------------------------*/ - float error; - float best_error; - spline_type spline; - spline_type best_spline; - spline_list_type * spline_list; - unsigned int worst_point; - float previous_error; - - best_error = FLT_MAX; /* initial value */ - previous_error = FLT_MAX; /* initial value */ - spline_list = NULL; /* initial value */ - worst_point = 0; /* initial value */ + float_coord const tangentPoint = CURVE_POINT(curveP, 0); + vector_type const zeroZero = { 0.0, 0.0 }; + unsigned int const surround = + MIN(CURVE_LENGTH(curveP) / 2, tangentSurround); - LOG ("\nFitting with least squares:\n"); - - /* Phoenix reduces the number of points with a ``linear spline - technique''. But for fitting letterforms, that is - inappropriate. We want all the points we can get. - */ + unsigned int p; + vector_type sum; + vector_type mean; + unsigned int n; + + for (p = 0, n = 0, sum = zeroZero; p < surround; ++p) { + unsigned int const thisIndex = p + 1; + float_coord const thisPoint = CURVE_POINT(curveP, thisIndex); + + /* Perhaps we should weight the tangent from `thisPoint' by some + factor dependent on the distance from the tangent point. + */ + sum = Vadd(sum, Pdirection(thisPoint, tangentPoint)); + ++n; + } + + mean = Vmult_scalar(sum, 1.0 / n); + + return mean; +} + + + +static vector_type +findHalfTangentEnd(curve * const curveP, + unsigned int const tangentSurround) { +/*---------------------------------------------------------------------------- + Find the slope in the vicinity of the end of the curve + *curveP. + + This is analogous to findHalfTangentBeg(), but at the other end of the + curve. +-----------------------------------------------------------------------------*/ + float_coord const tangentPoint = + CURVE_POINT(curveP, CURVE_LENGTH(curveP) - 1); + vector_type const zeroZero = { 0.0, 0.0 }; + unsigned int const surround = + MIN(CURVE_LENGTH(curveP) / 2, tangentSurround); + + unsigned int p; + vector_type sum; + vector_type mean; + unsigned int n; + + for (p = 0, n = 0, sum = zeroZero; p < surround; ++p) { + unsigned int const thisIndex = CURVE_LENGTH(curveP) - 1 - p; + float_coord const thisPoint = CURVE_POINT(curveP, thisIndex); + + sum = Vadd(sum, Pdirection(tangentPoint, thisPoint)); + ++n; + } + + mean = Vmult_scalar(sum, 1.0 / n); + + return mean; +} + + + +static vector_type +findHalfTangent(bool const toStartPoint, + curve * const curveP, + unsigned int const tangentSurround) { + + if (toStartPoint) + return findHalfTangentBeg(curveP, tangentSurround); + else + return findHalfTangentEnd(curveP, tangentSurround); +} + + + +static void +findTangent(curve * const curveP, + bool const toStartPoint, + curve * const adjacentCurveP, + unsigned int const tangentSurroundArg, + vector_type * const tangentP) { +/*---------------------------------------------------------------------------- + Find an approximation to the slope of *curveP (i.e. slope of tangent + line) at an endpoint (the first point if 'toStartPoint' is true, + else the last). + + If 'adjacentCurveP' is non-null, consider points on the adjacent + curve to *curveP. The adjacent curve is *adjacentCurveP. Adjacent + means the previous curve in the outline chain for the slope at the + start point ('toStartPoint' == true), the next curve otherwise. + If *curveP is cyclic, then it is its own adjacent curve. + + It is important to compute an accurate approximation, because the + control points that we eventually decide upon to fit the curve will + be placed on the half-lines defined by the slopes and endpoints, and + we never recompute the tangent after this. +-----------------------------------------------------------------------------*/ + vector_type slope; + unsigned int tangentSurround; + + LOG2(" tangent to %s of curve %lx: ", + toStartPoint ? "start" : "end", (unsigned long)curveP); + + tangentSurround = tangentSurroundArg; /* initial value */ + do { + slope = findHalfTangent(toStartPoint, curveP, tangentSurround); + + if (adjacentCurveP) { + vector_type const slopeAdj = + findHalfTangent(!toStartPoint, adjacentCurveP, + tangentSurround); + + LOG3("(adjacent curve half tangent (%.3f,%.3f,%.3f)) ", + slopeAdj.dx, slopeAdj.dy, slopeAdj.dz); + slope = Vmult_scalar(Vadd(slope, slopeAdj), 0.5); + } + --tangentSurround; + } while (slope.dx == 0.0 && slope.dy == 0.0); + + *tangentP = slope; - /* It makes no difference whether we first set the `t' values or - find the tangents. This order makes the documentation a little - more coherent. - */ + LOG3("(%.3f,%.3f,%.3f).\n", + tangentP->dx, tangentP->dy, tangentP->dz); +} - LOG("Finding tangents:\n"); - find_tangent(curve, /* to_start */ true, /* cross_curve */ false, - fitting_opts->tangent_surround); - find_tangent(curve, /* to_start */ false, /* cross_curve */ false, - fitting_opts->tangent_surround); - set_initial_parameter_values(curve); - /* Now we loop, subdividing, until CURVE has been fit. */ - while (true) { - float error; +static void +findError(curve * const curveP, + spline_type const spline, + float * const errorP, + unsigned int * const worstPointP, + at_exception_type * const exceptionP) { +/*---------------------------------------------------------------------------- + Tell how good a fit 'spline' is for *curveP. + + Return the error (maximum Euclidian distance between a point on + *curveP and the corresponding point on 'spline') as *errorP and the + sequence number of the point on the curve where the error is + greatest as *worstPointP. + + If there are multiple equally bad points, return an arbitrary one of + them as *worstPointP. +-----------------------------------------------------------------------------*/ + unsigned int thisPoint; + float totalError; + float worstError; + unsigned int worstPoint; - spline = fit_one_spline(curve, exception); - best_spline = spline; - if (at_exception_got_fatal(exception)) - goto cleanup; + assert(CURVE_LENGTH(curveP) > 0); - logSplineFit(spline); + totalError = 0.0; /* initial value */ + worstError = FLT_MIN; /* initial value */ + worstPoint = 0; - if (SPLINE_DEGREE(spline) == LINEARTYPE) - break; - - error = find_error(curve, spline, &worst_point, exception); - if (error <= previous_error) { - best_error = error; - best_spline = spline; + for (thisPoint = 0; thisPoint < CURVE_LENGTH(curveP); ++thisPoint) { + float_coord const curvePoint = CURVE_POINT(curveP, thisPoint); + float const t = CURVE_T(curveP, thisPoint); + float_coord const splinePoint = evaluate_spline(spline, t); + float const thisError = distance(curvePoint, splinePoint); + if (thisError >= worstError) { + worstPoint = thisPoint; + worstError = thisError; } - break; + totalError += thisError; } - if (SPLINE_DEGREE(spline) == LINEARTYPE) { - spline_list = new_spline_list_with_spline(spline); - LOG1("Accepted error of %.3f.\n", error); - return spline_list; + if (epsilon_equal(totalError, 0.0)) + LOG(" Every point fits perfectly.\n"); + else { + LOG5(" Worst error (at (%.3f,%.3f,%.3f), point #%u) was %.3f.\n", + CURVE_POINT(curveP, worstPoint).x, + CURVE_POINT(curveP, worstPoint).y, + CURVE_POINT(curveP, worstPoint).z, + worstPoint, worstError); + LOG1(" Total error was %.3f.\n", totalError); + LOG2(" Average error (over %u points) was %.3f.\n", + CURVE_LENGTH(curveP), totalError / CURVE_LENGTH(curveP)); } + assert(worstPoint < CURVE_LENGTH(curveP)); + *errorP = worstError; + *worstPointP = worstPoint; +} + + + +static void +setInitialParameterValues(curve * const curveP) { +/*---------------------------------------------------------------------------- + Fill in the 't' values in *curveP. - /* Go back to the best fit. */ - spline = best_spline; - error = best_error; + The t value for point P on a curve is the distance P is along the + curve from the initial point, normalized so the entire curve is + length 1.0 (i.e. t of the initial point is 0.0; t of the final + point is 1.0). - if (error < fitting_opts->error_threshold && !CURVE_CYCLIC(curve)) { - /* The points were fitted with a spline. We end up here - whenever a fit is accepted. We have one more job: see if - the ``curve'' that was fit should really be a straight - line. + There are a lot of curves that pass through the points indicated by + *curveP, but for practical computation of t, we just take the + piecewise linear locus that runs through all of them. That means + we can just step through *curveP, adding up the distance from one + point to the next to get the t value for each point. + + This is the "chord-length parameterization" method, which is + described in Plass & Stone. +-----------------------------------------------------------------------------*/ + unsigned int p; + + LOG("\nAssigning initial t values:\n "); + + CURVE_T(curveP, 0) = 0.0; + + for (p = 1; p < CURVE_LENGTH(curveP); ++p) { + float_coord const point = CURVE_POINT(curveP, p); + float_coord const previous_p = CURVE_POINT(curveP, p - 1); + float const d = distance(point, previous_p); + CURVE_T(curveP, p) = CURVE_T(curveP, p - 1) + d; + } + + assert(LAST_CURVE_T(curveP) != 0.0); + + /* Normalize to a curve length of 1.0 */ + + for (p = 1; p < CURVE_LENGTH(curveP); ++p) + CURVE_T(curveP, p) = CURVE_T(curveP, p) / LAST_CURVE_T(curveP); + + log_entire_curve(curveP); +} + + + +static void +subdivideCurve(curve * const curveP, + unsigned int const subdivisionIndex, + const fitting_opts_type * const fittingOptsP, + curve ** const leftCurvePP, + curve ** const rghtCurvePP, + vector_type * const joinSlopeP) { +/*---------------------------------------------------------------------------- + Split curve *curveP into two, at 'subdivisionIndex'. (Actually, + leave *curveP alone, but return as *leftCurvePP and *rghtCurvePP + two new curves that are the pieces). + + Return as *joinSlopeP what should be the slope where the subcurves + join, i.e. the slope of the end of the left subcurve and of the start + of the right subcurve. + + To be precise, the point with sequence number 'subdivisionIndex' + becomes the first pixel of the right-hand curve. +-----------------------------------------------------------------------------*/ + curve * leftCurveP; + curve * rghtCurveP; + + leftCurveP = new_curve(); + rghtCurveP = new_curve(); + + LOG4(" Subdividing curve %lx into %lx and %lx at point #%u\n", + (unsigned long)curveP, + (unsigned long)leftCurveP, (unsigned long)rghtCurveP, + subdivisionIndex); + + /* The last point of the left-hand curve will also be the first + point of the right-hand curve. + */ + assert(subdivisionIndex < CURVE_LENGTH(curveP)); + CURVE_LENGTH(leftCurveP) = subdivisionIndex + 1; + CURVE_LENGTH(rghtCurveP) = CURVE_LENGTH(curveP) - subdivisionIndex; + + MALLOCARRAY_NOFAIL(leftCurveP->point_list, CURVE_LENGTH(leftCurveP)); + memcpy(leftCurveP->point_list, &curveP->point_list[0], + CURVE_LENGTH(leftCurveP) * sizeof(curveP->point_list[0])); + + MALLOCARRAY_NOFAIL(rghtCurveP->point_list, CURVE_LENGTH(rghtCurveP)); + memcpy(rghtCurveP->point_list, &curveP->point_list[subdivisionIndex], + CURVE_LENGTH(rghtCurveP) * sizeof(curveP->point_list[0])); + + /* We have to set up the two curves before finding the slope at + the subdivision point. The slope at that point must be the + same for both curves, or noticeable bumps will occur in the + character. But we want to use information on both sides of the + point to compute the slope, hence we use adjacentCurveP. + */ + findTangent(leftCurveP, + /* toStartPoint: */ false, + /* adjacentCurveP: */ rghtCurveP, + fittingOptsP->tangent_surround, joinSlopeP); + + *leftCurvePP = leftCurveP; + *rghtCurvePP = rghtCurveP; +} + + + +static spline_list_type * +leftRightConcat(const spline_list_type * const leftSplineListP, + const spline_list_type * const rghtSplineListP, + at_exception_type * const exceptionP) { +/*---------------------------------------------------------------------------- + Return a spline list which is the concatenation of the spline lists + obtained by splitting a curve in two and fitting each independently. + NULL for a spline list pointer means Caller was unable to fit a list + of splines to that side of the curve. +-----------------------------------------------------------------------------*/ + spline_list_type * retval; + + retval = new_spline_list(); + + if (leftSplineListP == NULL) { + LOG("Could not fit spline to left curve.\n"); + at_exception_warning(exceptionP, "Could not fit left spline list"); + } else + concat_spline_lists(retval, *leftSplineListP); + + if (rghtSplineListP == NULL) { + LOG("Could not fit spline to right curve.\n"); + at_exception_warning(exceptionP, "Could not fit right spline list"); + } else + concat_spline_lists(retval, *rghtSplineListP); + + return retval; +} + + + +static unsigned int +divisionPoint(curve * const curveP, + unsigned int const worstFitPoint) { +/*---------------------------------------------------------------------------- + Return the sequence number of the point at which we should divide + curve *curveP for the purpose of doing a separate fit of each side, + assuming the point which least matches a single spline is sequence + number 'worstFitPoint'. + + We get as close as we can to that while still having at least two + points on each side. + + Assume the curve is at least 4 points long. + + The return value is the sequence number of the first point of the + second (right-hand) subcurve. +-----------------------------------------------------------------------------*/ + assert(CURVE_LENGTH(curveP) >= 4); + + return MAX(2, MIN(worstFitPoint, CURVE_LENGTH(curveP) - 2)); +} + + + +static spline_list_type * +divideAndFit(curve * const curveP, + vector_type const begSlope, + vector_type const endSlope, + unsigned int const subdivisionIndex, + const fitting_opts_type * const fittingOptsP, + at_exception_type * const exceptionP) { +/*---------------------------------------------------------------------------- + Same as fitWithLeastSquares() (i.e. return a list of splines that fit + the curve *curveP), except assuming no single spline will fit the + entire curve. + + Divide it into two curves at 'subdivisionIndex' and fit each + separately to a list of splines. Return the concatenation of those + spline lists. + + Assume 'subdivisionIndex' leaves at least two pixels on each side. +-----------------------------------------------------------------------------*/ + spline_list_type * retval; + curve * leftCurveP; + /* The beginning (lower indexes) subcurve */ + curve * rghtCurveP; + /* The other subcurve */ + vector_type joinSlope; + /* The slope of the end of the left subcurve and start of the right + subcurve. */ - if (spline_linear_enough(&spline, curve, fitting_opts)) { - SPLINE_DEGREE(spline) = LINEARTYPE; - LOG("Changed to line.\n"); + spline_list_type * leftSplineListP; + + assert(subdivisionIndex > 1); + assert(subdivisionIndex < CURVE_LENGTH(curveP)-1); + subdivideCurve(curveP, subdivisionIndex, fittingOptsP, + &leftCurveP, &rghtCurveP, &joinSlope); + + leftSplineListP = fitCurve(leftCurveP, begSlope, joinSlope, + fittingOptsP, exceptionP); + + if (!at_exception_got_fatal(exceptionP)) { + spline_list_type * rghtSplineListP; + + rghtSplineListP = fitCurve(rghtCurveP, joinSlope, endSlope, + fittingOptsP, exceptionP); + + if (!at_exception_got_fatal(exceptionP)) { + if (leftSplineListP == NULL && rghtSplineListP == NULL) + retval = NULL; + else + retval = leftRightConcat(leftSplineListP, rghtSplineListP, + exceptionP); + + if (rghtSplineListP) { + free_spline_list(*rghtSplineListP); + free(rghtSplineListP); + } } - spline_list = new_spline_list_with_spline(spline); - LOG1("Accepted error of %.3f.\n", error); - } else { - /* We couldn't fit the curve acceptably, so subdivide. */ - unsigned subdivision_index; - spline_list_type * left_spline_list; - spline_list_type * right_spline_list; - curve_type left_curve, right_curve; - - left_curve = new_curve(); - right_curve = new_curve(); - - /* Insert 'left_curve', then 'right_curve' after 'curve' in the list */ - NEXT_CURVE(right_curve) = NEXT_CURVE(curve); - PREVIOUS_CURVE(right_curve) = left_curve; - NEXT_CURVE(left_curve) = right_curve; - PREVIOUS_CURVE(left_curve) = curve; - NEXT_CURVE(curve) = left_curve; - - LOG1("\nSubdividing (error %.3f):\n", error); - LOG3(" Original point: (%.3f,%.3f), #%u.\n", - CURVE_POINT (curve, worst_point).x, - CURVE_POINT (curve, worst_point).y, worst_point); - subdivision_index = worst_point; - LOG3 (" Final point: (%.3f,%.3f), #%u.\n", - CURVE_POINT (curve, subdivision_index).x, - CURVE_POINT (curve, subdivision_index).y, subdivision_index); - - /* The last point of the left-hand curve will also be the first - point of the right-hand curve. */ - CURVE_LENGTH(left_curve) = subdivision_index + 1; - CURVE_LENGTH(right_curve) = CURVE_LENGTH(curve) - subdivision_index; - left_curve->point_list = curve->point_list; - right_curve->point_list = curve->point_list + subdivision_index; - - /* We want to use the tangents of the curve which we are - subdividing for the start tangent for left_curve and the - end tangent for right_curve. - */ - CURVE_START_TANGENT(left_curve) = CURVE_START_TANGENT(curve); - CURVE_END_TANGENT(right_curve) = CURVE_END_TANGENT(curve); - - /* We have to set up the two curves before finding the tangent at - the subdivision point. The tangent at that point must be the - same for both curves, or noticeable bumps will occur in the - character. But we want to use information on both sides of the - point to compute the tangent, hence cross_curve = true. - */ - find_tangent(left_curve, /* to_start_point: */ false, - /* cross_curve: */ true, fitting_opts->tangent_surround); - CURVE_START_TANGENT(right_curve) = CURVE_END_TANGENT(left_curve); - - /* Now that we've set up the curves, we can fit them. */ - left_spline_list = fitCurve(left_curve, fitting_opts, exception); - if (at_exception_got_fatal(exception)) - /* TODO: Memory allocated for left_curve and right_curve - will leak.*/ - goto cleanup; + if (leftSplineListP) { + free_spline_list(*leftSplineListP); + free(leftSplineListP); + } + } - right_spline_list = fitCurve(right_curve, fitting_opts, exception); - /* TODO: Memory allocated for left_curve and right_curve - will leak.*/ - if (at_exception_got_fatal(exception)) - goto cleanup; - - /* Neither of the subdivided curves could be fit, so fail. */ - if (left_spline_list == NULL && right_spline_list == NULL) - return NULL; + free_curve(leftCurveP); + free_curve(rghtCurveP); - /* Put the two together (or whichever of them exist). */ - spline_list = new_spline_list(); + return retval; +} - if (left_spline_list == NULL) { - LOG1("Could not fit spline to left curve (%lx).\n", - (unsigned long) left_curve); - at_exception_warning(exception, "Could not fit left spline list"); - } else { - concat_spline_lists(spline_list, *left_spline_list); - free_spline_list(*left_spline_list); - free(left_spline_list); + + +static spline_list_type * +fitWithLeastSquares(curve * const curveP, + vector_type const begSlope, + vector_type const endSlope, + const fitting_opts_type * const fittingOptsP, + at_exception_type * const exceptionP) { +/*---------------------------------------------------------------------------- + The least squares method is well described in Schneider's thesis. + Briefly, we try to fit the entire curve with one spline. If that + fails, we subdivide the curve. +-----------------------------------------------------------------------------*/ + spline_list_type * retval; + spline_type spline; + + LOG("\nFitting with least squares:\n"); + + /* Phoenix reduces the number of points with a "linear spline + technique." But for fitting letterforms, that is + inappropriate. We want all the points we can get. + */ + + setInitialParameterValues(curveP); + + if (CURVE_CYCLIC(curveP) && CURVE_LENGTH(curveP) < 4) { + unsigned i; + for (i = 0; i < CURVE_LENGTH(curveP); ++i) { + float_coord const point = CURVE_POINT(curveP, i); + fprintf(stderr, "point %u = (%f, %f)\n", i, point.x, point.y); } + } + + /* Try a single spline over whole curve */ + + spline = fitOneSpline(curveP, begSlope, endSlope, exceptionP); + if (!at_exception_got_fatal(exceptionP)) { + float error; + unsigned int worstPoint; + + logSplineFit(spline); - if (right_spline_list == NULL) { - LOG1("Could not fit spline to right curve (%lx).\n", - (unsigned long) right_curve); - at_exception_warning(exception, "Could not fit right spline list"); + findError(curveP, spline, &error, &worstPoint, exceptionP); + assert(worstPoint < CURVE_LENGTH(curveP)); + + if (error < fittingOptsP->error_threshold && !CURVE_CYCLIC(curveP)) { + /* The points were fitted adequately with a spline. But + see if the "curve" that was fit should really just be a + straight line. + */ + if (spline_linear_enough(&spline, curveP, fittingOptsP)) { + SPLINE_DEGREE(spline) = LINEARTYPE; + LOG("Changed to line.\n"); + } + retval = new_spline_list_with_spline(spline); + LOG1("Accepted error of %.3f.\n", error); } else { - concat_spline_lists(spline_list, *right_spline_list); - free_spline_list(*right_spline_list); - free(right_spline_list); + /* We couldn't fit the curve acceptably with a single spline, + so divide into two curves and try to fit each separately. + */ + unsigned int const divIndex = divisionPoint(curveP, worstPoint); + LOG1("\nSubdividing at point #%u\n", divIndex); + LOG4(" Worst match point: (%.3f,%.3f), #%u. Error %.3f\n", + CURVE_POINT(curveP, worstPoint).x, + CURVE_POINT(curveP, worstPoint).y, worstPoint, error); + + retval = divideAndFit(curveP, begSlope, endSlope, divIndex, + fittingOptsP, exceptionP); } - if (CURVE_END_TANGENT(left_curve)) - free(CURVE_END_TANGENT(left_curve)); - free(left_curve); - free(right_curve); - } -cleanup: + } else + retval = NULL; /* quiet compiler warning */ - return spline_list; + return retval; } static spline_list_type * -fitCurve(curve_type const curve, +fitCurve(curve * const curveP, + vector_type const begSlope, + vector_type const endSlope, const fitting_opts_type * const fittingOptsP, - at_exception_type * const exception) { + at_exception_type * const exceptionP) { /*---------------------------------------------------------------------------- Transform a set of locations to a list of splines (the fewer the - better). We are guaranteed that CURVE does not contain any corners. + better). We are guaranteed that *curveP does not contain any corners. We return NULL if we cannot fit the points at all. -----------------------------------------------------------------------------*/ spline_list_type * fittedSplinesP; - if (CURVE_LENGTH(curve) < 2) { - LOG("Tried to fit curve with less than two points"); - at_exception_warning(exception, + if (CURVE_LENGTH(curveP) < 2) { + LOG("Tried to fit curve with fewer than two points"); + at_exception_warning(exceptionP, "Tried to fit curve with less than two points"); fittedSplinesP = NULL; - } else if (CURVE_LENGTH(curve) < 4) - fittedSplinesP = fit_with_line(curve); + } else if (CURVE_LENGTH(curveP) < 4) + fittedSplinesP = fitWithLine(curveP); else fittedSplinesP = - fit_with_least_squares(curve, fittingOptsP, exception); + fitWithLeastSquares(curveP, begSlope, endSlope, fittingOptsP, + exceptionP); return fittedSplinesP; } @@ -1185,13 +1908,24 @@ fitCurves(curve_list_type const curveList, curveSeq < curveList.length && !at_exception_got_fatal(exceptionP); ++curveSeq) { - curve_type const currentCurve = CURVE_LIST_ELT(curveList, curveSeq); + curve * const curveP = CURVE_LIST_ELT(curveList, curveSeq); + vector_type begSlope, endSlope; spline_list_type * curveSplinesP; - LOG1("\nFitting curve #%u:\n", curveSeq); + LOG2("\nFitting curve #%u (%lx):\n", curveSeq, (unsigned long)curveP); - curveSplinesP = fitCurve(currentCurve, fittingOptsP, exceptionP); + LOG("Finding tangents:\n"); + findTangent(curveP, /* toStart */ true, + CURVE_CYCLIC(curveP) ? curveP : NULL, + fittingOptsP->tangent_surround, + &begSlope); + findTangent(curveP, /* toStart */ false, + CURVE_CYCLIC(curveP) ? curveP : NULL, + fittingOptsP->tangent_surround, &endSlope); + + curveSplinesP = fitCurve(curveP, begSlope, endSlope, fittingOptsP, + exceptionP); if (!at_exception_got_fatal(exceptionP)) { if (curveSplinesP == NULL) { LOG1("Could not fit curve #%u", curveSeq); @@ -1369,7 +2103,6 @@ fit_outlines_to_splines(pixel_outline_list_type const pixelOutlineList, exception, notifyProgress, progressData, testCancel, testcancelData, splineListArrayP); - free_curve_list_array(&curveListArray, notifyProgress, progressData); flush_log_output(); @@ -1377,548 +2110,3 @@ fit_outlines_to_splines(pixel_outline_list_type const pixelOutlineList, - -static void -find_vectors(unsigned int const test_index, - pixel_outline_type const outline, - vector_type * const in, - vector_type * const out, - unsigned int const corner_surround) { -/*---------------------------------------------------------------------------- - Return the difference vectors coming in and going out of the outline - OUTLINE at the point whose index is TEST_INDEX. In Phoenix, - Schneider looks at a single point on either side of the point we're - considering. That works for him because his points are not touching. - But our points *are* touching, and so we have to look at - `corner_surround' points on either side, to get a better picture of - the outline's shape. ------------------------------------------------------------------------------*/ - int i; - unsigned n_done; - pm_pixelcoord const candidate = O_COORDINATE(outline, test_index); - - in->dx = in->dy = in->dz = 0.0; - out->dx = out->dy = out->dz = 0.0; - - /* Add up the differences from p of the `corner_surround' points - before p. - */ - for (i = O_PREV(outline, test_index), n_done = 0; - n_done < corner_surround; - i = O_PREV(outline, i), ++n_done) - *in = Vadd(*in, IPsubtract(O_COORDINATE(outline, i), candidate)); - - /* And the points after p. */ - for (i = O_NEXT (outline, test_index), n_done = 0; - n_done < corner_surround; - i = O_NEXT(outline, i), ++n_done) - *out = Vadd(*out, IPsubtract(O_COORDINATE(outline, i), candidate)); -} - - - -/* Remove adjacent points from the index list LIST. We do this by first - sorting the list and then running through it. Since these lists are - quite short, a straight selection sort (e.g., p.139 of the Art of - Computer Programming, vol.3) is good enough. LAST_INDEX is the index - of the last pixel on the outline, i.e., the next one is the first - pixel. We need this for checking the adjacency of the last corner. - - We need to do this because the adjacent corners turn into - two-pixel-long curves, which can only be fit by straight lines. */ - -static void -remove_adjacent_corners (index_list_type *list, unsigned last_index, - bool remove_adj_corners, - at_exception_type * exception) - -{ - unsigned j; - unsigned last; - index_list_type new_list = new_index_list (); - - for (j = INDEX_LIST_LENGTH (*list) - 1; j > 0; j--) - { - unsigned search; - unsigned temp; - /* Find maximal element below `j'. */ - unsigned max_index = j; - - for (search = 0; search < j; search++) - if (GET_INDEX (*list, search) > GET_INDEX (*list, max_index)) - max_index = search; - - if (max_index != j) - { - temp = GET_INDEX (*list, j); - GET_INDEX (*list, j) = GET_INDEX (*list, max_index); - GET_INDEX (*list, max_index) = temp; - - /* xx -- really have to sort? */ - LOG ("needed exchange"); - at_exception_warning(exception, "needed exchange"); - } - } - - /* The list is sorted. Now look for adjacent entries. Each time - through the loop we insert the current entry and, if appropriate, - the next entry. */ - for (j = 0; j < INDEX_LIST_LENGTH (*list) - 1; j++) - { - unsigned current = GET_INDEX (*list, j); - unsigned next = GET_INDEX (*list, j + 1); - - /* We should never have inserted the same element twice. */ - /* assert (current != next); */ - - if ((remove_adj_corners) && ((next == current + 1) || (next == current))) - j++; - - append_index (&new_list, current); - } - - /* Don't append the last element if it is 1) adjacent to the previous - one; or 2) adjacent to the very first one. */ - last = GET_LAST_INDEX (*list); - if (INDEX_LIST_LENGTH (new_list) == 0 - || !(last == GET_LAST_INDEX (new_list) + 1 - || (last == last_index && GET_INDEX (*list, 0) == 0))) - append_index (&new_list, last); - - free_index_list (list); - *list = new_list; -} - -/* A ``knee'' is a point which forms a ``right angle'' with its - predecessor and successor. See the documentation (the `Removing - knees' section) for an example and more details. - - The argument CLOCKWISE tells us which direction we're moving. (We - can't figure that information out from just the single segment with - which we are given to work.) - - We should never find two consecutive knees. - - Since the first and last points are corners (unless the curve is - cyclic), it doesn't make sense to remove those. */ - -/* This evaluates to true if the vector V is zero in one direction and - nonzero in the other. */ -#define ONLY_ONE_ZERO(v) \ - (((v).dx == 0.0 && (v).dy != 0.0) || ((v).dy == 0.0 && (v).dx != 0.0)) - -/* There are four possible cases for knees, one for each of the four - corners of a rectangle; and then the cases differ depending on which - direction we are going around the curve. The tests are listed here - in the order of upper left, upper right, lower right, lower left. - Perhaps there is some simple pattern to the - clockwise/counterclockwise differences, but I don't see one. */ -#define CLOCKWISE_KNEE(prev_delta, next_delta) \ - ((prev_delta.dx == -1.0 && next_delta.dy == 1.0) \ - || (prev_delta.dy == 1.0 && next_delta.dx == 1.0) \ - || (prev_delta.dx == 1.0 && next_delta.dy == -1.0) \ - || (prev_delta.dy == -1.0 && next_delta.dx == -1.0)) - -#define COUNTERCLOCKWISE_KNEE(prev_delta, next_delta) \ - ((prev_delta.dy == 1.0 && next_delta.dx == -1.0) \ - || (prev_delta.dx == 1.0 && next_delta.dy == 1.0) \ - || (prev_delta.dy == -1.0 && next_delta.dx == 1.0) \ - || (prev_delta.dx == -1.0 && next_delta.dy == -1.0)) - - - -static void -remove_knee_points(curve_type const curve, - bool const clockwise) { - - unsigned const offset = (CURVE_CYCLIC(curve) == true) ? 0 : 1; - curve_type const trimmed_curve = copy_most_of_curve(curve); - - pm_pixelcoord previous; - unsigned i; - - if (!CURVE_CYCLIC(curve)) - append_pixel(trimmed_curve, - real_to_int_coord(CURVE_POINT(curve, 0))); - - previous = real_to_int_coord(CURVE_POINT(curve, - CURVE_PREV(curve, offset))); - - for (i = offset; i < CURVE_LENGTH (curve) - offset; ++i) { - pm_pixelcoord const current = - real_to_int_coord(CURVE_POINT(curve, i)); - pm_pixelcoord const next = - real_to_int_coord(CURVE_POINT(curve, CURVE_NEXT(curve, i))); - vector_type const prev_delta = IPsubtract(previous, current); - vector_type const next_delta = IPsubtract(next, current); - - if (ONLY_ONE_ZERO(prev_delta) && ONLY_ONE_ZERO(next_delta) - && ((clockwise && CLOCKWISE_KNEE(prev_delta, next_delta)) - || (!clockwise - && COUNTERCLOCKWISE_KNEE(prev_delta, next_delta)))) - LOG2(" (%d,%d)", current.col, current.row); - else { - previous = current; - append_pixel(trimmed_curve, current); - } - } - - if (!CURVE_CYCLIC(curve)) - append_pixel(trimmed_curve, - real_to_int_coord(LAST_CURVE_POINT(curve))); - - if (CURVE_LENGTH(trimmed_curve) == CURVE_LENGTH(curve)) - LOG(" (none)"); - - LOG(".\n"); - - free_curve(curve); - *curve = *trimmed_curve; - free(trimmed_curve); /* free_curve? --- Masatake */ -} - - - -/* Smooth the curve by adding in neighboring points. Do this - `filter_iterations' times. But don't change the corners. */ - -static void -filter (curve_type curve, fitting_opts_type *fitting_opts) -{ - unsigned iteration, this_point; - unsigned offset = (CURVE_CYCLIC (curve) == true) ? 0 : 1; - float_coord prev_new_point; - - /* We must have at least three points---the previous one, the current - one, and the next one. But if we don't have at least five, we will - probably collapse the curve down onto a single point, which means - we won't be able to fit it with a spline. */ - if (CURVE_LENGTH (curve) < 5) - { - LOG1 ("Length is %u, not enough to filter.\n", CURVE_LENGTH (curve)); - return; - } - - prev_new_point.x = FLT_MAX; - prev_new_point.y = FLT_MAX; - prev_new_point.z = FLT_MAX; - - for (iteration = 0; iteration < fitting_opts->filter_iterations; - iteration++) - { - curve_type newcurve = copy_most_of_curve (curve); - bool collapsed = false; - - /* Keep the first point on the curve. */ - if (offset) - append_point (newcurve, CURVE_POINT (curve, 0)); - - for (this_point = offset; this_point < CURVE_LENGTH (curve) - offset; - this_point++) - { - vector_type in, out, sum; - float_coord new_point; - - /* Calculate the vectors in and out, computed by looking at n points - on either side of this_point. Experimental it was found that 2 is - optimal. */ - - signed int prev, prevprev; /* have to be signed */ - unsigned int next, nextnext; - float_coord candidate = CURVE_POINT (curve, this_point); - - prev = CURVE_PREV (curve, this_point); - prevprev = CURVE_PREV (curve, prev); - next = CURVE_NEXT (curve, this_point); - nextnext = CURVE_NEXT (curve, next); - - /* Add up the differences from p of the `surround' points - before p. */ - in.dx = in.dy = in.dz = 0.0; - - in = Vadd (in, Psubtract (CURVE_POINT (curve, prev), candidate)); - if (prevprev >= 0) - in = Vadd (in, Psubtract (CURVE_POINT (curve, prevprev), candidate)); - - /* And the points after p. Don't use more points after p than we - ended up with before it. */ - out.dx = out.dy = out.dz = 0.0; - - out = Vadd (out, Psubtract (CURVE_POINT (curve, next), candidate)); - if (nextnext < CURVE_LENGTH (curve)) - out = Vadd (out, Psubtract (CURVE_POINT (curve, nextnext), candidate)); - - /* Start with the old point. */ - new_point = candidate; - sum = Vadd (in, out); - /* We added 2*n+2 points, so we have to divide the sum by 2*n+2 */ - new_point.x += sum.dx / 6; - new_point.y += sum.dy / 6; - new_point.z += sum.dz / 6; - if (fabs (prev_new_point.x - new_point.x) < 0.3 - && fabs (prev_new_point.y - new_point.y) < 0.3 - && fabs (prev_new_point.z - new_point.z) < 0.3) - { - collapsed = true; - break; - } - - - /* Put the newly computed point into a separate curve, so it - doesn't affect future computation (on this iteration). */ - append_point (newcurve, prev_new_point = new_point); - } - - if (collapsed) - free_curve (newcurve); - else - { - /* Just as with the first point, we have to keep the last point. */ - if (offset) - append_point (newcurve, LAST_CURVE_POINT (curve)); - - /* Set the original curve to the newly filtered one, and go again. */ - free_curve (curve); - *curve = *newcurve; - } - free (newcurve); - } - - log_curve (curve, false); -} - - - -/* Find reasonable values for t for each point on CURVE. The method is - called chord-length parameterization, which is described in Plass & - Stone. The basic idea is just to use the distance from one point to - the next as the t value, normalized to produce values that increase - from zero for the first point to one for the last point. */ - -static void -set_initial_parameter_values (curve_type curve) -{ - unsigned p; - - LOG ("\nAssigning initial t values:\n "); - - CURVE_T (curve, 0) = 0.0; - - for (p = 1; p < CURVE_LENGTH (curve); p++) - { - float_coord point = CURVE_POINT (curve, p), - previous_p = CURVE_POINT (curve, p - 1); - float d = distance (point, previous_p); - CURVE_T (curve, p) = CURVE_T (curve, p - 1) + d; - } - - assert (LAST_CURVE_T (curve) != 0.0); - - for (p = 1; p < CURVE_LENGTH (curve); p++) - CURVE_T (curve, p) = CURVE_T (curve, p) / LAST_CURVE_T (curve); - - log_entire_curve (curve); -} - -/* Find an approximation to the tangent to an endpoint of CURVE (to the - first point if TO_START_POINT is true, else the last). If - CROSS_CURVE is true, consider points on the adjacent curve to CURVE. - - It is important to compute an accurate approximation, because the - control points that we eventually decide upon to fit the curve will - be placed on the half-lines defined by the tangents and - endpoints...and we never recompute the tangent after this. */ - -static void -find_tangent (curve_type curve, bool to_start_point, bool cross_curve, - unsigned tangent_surround) -{ - vector_type tangent; - vector_type **curve_tangent = (to_start_point == true) ? &(CURVE_START_TANGENT (curve)) - : &(CURVE_END_TANGENT (curve)); - unsigned n_points = 0; - - LOG1 (" tangent to %s: ", (to_start_point == true) ? "start" : "end"); - - if (*curve_tangent == NULL) - { - MALLOCVAR_NOFAIL(*curve_tangent); - do - { - tangent = find_half_tangent (curve, to_start_point, &n_points, - tangent_surround); - - if ((cross_curve == true) || (CURVE_CYCLIC (curve) == true)) - { - curve_type adjacent_curve - = (to_start_point == true) ? PREVIOUS_CURVE (curve) : NEXT_CURVE (curve); - vector_type tangent2 - = (to_start_point == false) ? find_half_tangent (adjacent_curve, true, &n_points, - tangent_surround) : find_half_tangent (adjacent_curve, true, &n_points, - tangent_surround); - - LOG3 ("(adjacent curve half tangent (%.3f,%.3f,%.3f)) ", - tangent2.dx, tangent2.dy, tangent2.dz); - tangent = Vadd (tangent, tangent2); - } - tangent_surround--; - - } - while (tangent.dx == 0.0 && tangent.dy == 0.0); - - assert (n_points > 0); - **curve_tangent = Vmult_scalar (tangent, (float)(1.0 / n_points)); - if ((CURVE_CYCLIC (curve) == true) && CURVE_START_TANGENT (curve)) - *CURVE_START_TANGENT (curve) = **curve_tangent; - if ((CURVE_CYCLIC (curve) == true) && CURVE_END_TANGENT (curve)) - *CURVE_END_TANGENT (curve) = **curve_tangent; - } - else - LOG ("(already computed) "); - - LOG3 ("(%.3f,%.3f,%.3f).\n", (*curve_tangent)->dx, (*curve_tangent)->dy, (*curve_tangent)->dz); -} - -/* Find the change in y and change in x for `tangent_surround' (a global) - points along CURVE. Increment N_POINTS by the number of points we - actually look at. */ - -static vector_type -find_half_tangent (curve_type c, bool to_start_point, unsigned *n_points, - unsigned tangent_surround) -{ - unsigned p; - int factor = to_start_point ? 1 : -1; - unsigned tangent_index = to_start_point ? 0 : c->length - 1; - float_coord tangent_point = CURVE_POINT (c, tangent_index); - vector_type tangent = { 0.0, 0.0 }; - unsigned int surround; - - if ((surround = CURVE_LENGTH (c) / 2) > tangent_surround) - surround = tangent_surround; - - for (p = 1; p <= surround; p++) - { - int this_index = p * factor + tangent_index; - float_coord this_point; - - if (this_index < 0 || this_index >= (int) c->length) - break; - - this_point = CURVE_POINT (c, p * factor + tangent_index); - - /* Perhaps we should weight the tangent from `this_point' by some - factor dependent on the distance from the tangent point. */ - tangent = Vadd (tangent, - Vmult_scalar (Psubtract (this_point, tangent_point), - (float) factor)); - (*n_points)++; - } - - return tangent; -} - -/* When this routine is called, we have computed a spline representation - for the digitized curve. The question is, how good is it? If the - fit is very good indeed, we might have an error of zero on each - point, and then WORST_POINT becomes irrelevant. But normally, we - return the error at the worst point, and the index of that point in - WORST_POINT. The error computation itself is the Euclidean distance - from the original curve CURVE to the fitted spline SPLINE. */ - -static float -find_error (curve_type curve, spline_type spline, unsigned *worst_point, - at_exception_type * exception) -{ - unsigned this_point; - float total_error = 0.0; - float worst_error = FLT_MIN; - - *worst_point = CURVE_LENGTH (curve) + 1; /* A sentinel value. */ - - for (this_point = 0; this_point < CURVE_LENGTH (curve); this_point++) - { - float_coord curve_point = CURVE_POINT (curve, this_point); - float t = CURVE_T (curve, this_point); - float_coord spline_point = evaluate_spline (spline, t); - float this_error = distance (curve_point, spline_point); - if (this_error >= worst_error) - { - *worst_point = this_point; - worst_error = this_error; - } - total_error += this_error; - } - - if (*worst_point == CURVE_LENGTH (curve) + 1) - { /* Didn't have any ``worst point''; the error should be zero. */ - *worst_point = 0; - if (epsilon_equal (total_error, 0.0)) - LOG (" Every point fit perfectly.\n"); - else - { - LOG("No worst point found; something is wrong"); - at_exception_warning(exception, "No worst point found; something is wrong"); - } - } - else - { - if (epsilon_equal (total_error, 0.0)) - LOG (" Every point fit perfectly.\n"); - else - { - LOG5 (" Worst error (at (%.3f,%.3f,%.3f), point #%u) was %.3f.\n", - CURVE_POINT (curve, *worst_point).x, - CURVE_POINT (curve, *worst_point).y, - CURVE_POINT (curve, *worst_point).z, *worst_point, worst_error); - LOG1 (" Total error was %.3f.\n", total_error); - LOG2 (" Average error (over %u points) was %.3f.\n", - CURVE_LENGTH (curve), total_error / CURVE_LENGTH (curve)); - } - } - - return worst_error; -} - - -/* Lists of array indices (well, that is what we use it for). */ - -static index_list_type -new_index_list (void) -{ - index_list_type index_list; - - index_list.data = NULL; - INDEX_LIST_LENGTH (index_list) = 0; - - return index_list; -} - -static void -free_index_list (index_list_type *index_list) -{ - if (INDEX_LIST_LENGTH (*index_list) > 0) - { - free (index_list->data); - index_list->data = NULL; - INDEX_LIST_LENGTH (*index_list) = 0; - } -} - -static void -append_index (index_list_type *list, unsigned new_index) -{ - INDEX_LIST_LENGTH (*list)++; - REALLOCARRAY_NOFAIL(list->data, INDEX_LIST_LENGTH(*list)); - list->data[INDEX_LIST_LENGTH (*list) - 1] = new_index; -} - - -/* Return the Euclidean distance between P1 and P2. */ - -static float -distance (float_coord p1, float_coord p2) -{ - float x = p1.x - p2.x, y = p1.y - p2.y, z = p1.z - p2.z; - return (float) sqrt (SQR(x) + SQR(y) + SQR(z)); -} diff --git a/converter/other/pamtosvg/pamtosvg.c b/converter/other/pamtosvg/pamtosvg.c index 7262204c..dbe67c74 100644 --- a/converter/other/pamtosvg/pamtosvg.c +++ b/converter/other/pamtosvg/pamtosvg.c @@ -4,6 +4,7 @@ #include <assert.h> #include <math.h> +#include "pm_c_util.h" #include "mallocvar.h" #include "nstring.h" #include "shhopt.h" @@ -211,6 +212,7 @@ parseCommandLine(int argc, pm_error("Too many arguments (%u). The only non-option argument " "is the input file name.", argc-1); } + free(option_def); } @@ -389,7 +391,7 @@ main(int argc, char * argv[]) { pm_close(ifP); if (cmdline.log) pm_close(log_file); - + at_splines_free(splinesP); at_bitmap_free(bitmapP); diff --git a/converter/other/pamtosvg/pamtosvg.test b/converter/other/pamtosvg/pamtosvg.test index df3a07d3..3217287e 100644 --- a/converter/other/pamtosvg/pamtosvg.test +++ b/converter/other/pamtosvg/pamtosvg.test @@ -1,6 +1,8 @@ +echo "Test 1. Should print nothing" # This will print nothing if successful (diff will find no difference) -ppmmake black 20 20 | ppmdraw -script="line 5 2 15 17" | pamtosvg | \ +ppmmake black 20 20 | ppmdraw -script="line 5 2 15 17" | ./pamtosvg | \ diff testline.svg - +echo "Test 2. Should print nothing" # This will print nothing if successful (diff will find no difference) -pamtosvg ../../../../testgrid.pbm | diff testgrid.svg - +./pamtosvg ../../../testgrid.pbm | diff testgrid.svg - diff --git a/converter/other/pamtosvg/pxl-outline.c b/converter/other/pamtosvg/pxl-outline.c index a55a8b95..a1fa5299 100644 --- a/converter/other/pamtosvg/pxl-outline.c +++ b/converter/other/pamtosvg/pxl-outline.c @@ -83,8 +83,9 @@ getBitmapColor(bitmap_type const bitmap, unsigned int const row, unsigned int const col) { + unsigned char * const p = BITMAP_PIXEL(bitmap, row, col); + pixel pix; - unsigned char *p = BITMAP_PIXEL (bitmap, row, col); if (bitmap.np >= 3) PPM_ASSIGN(pix, p[0], p[1], p[2]); @@ -248,19 +249,19 @@ next_unmarked_pixel(unsigned int * const row, static pixel_outline_type -find_one_centerline(bitmap_type const bitmap, - direction_type const original_dir, - unsigned int const original_row, - unsigned int const original_col, - bitmap_type * const marked) { +findOneCenterline(bitmap_type const bitmap, + direction_type const originalDir, + unsigned int const originalRow, + unsigned int const originalCol, + bitmap_type * const marked) { - direction_type search_dir; + direction_type searchDir; unsigned int row, col; pixel_outline_type outline; outline = new_pixel_outline(); outline.open = false; - outline.color = getBitmapColor(bitmap, original_row, original_col); + outline.color = getBitmapColor(bitmap, originalRow, originalCol); /* Add the starting pixel to the output list, changing from bitmap to Cartesian coordinates and specifying the left edge so that @@ -268,22 +269,22 @@ find_one_centerline(bitmap_type const bitmap, */ { pm_pixelcoord pos; - pos.col = original_col; pos.row = bitmap.height - original_row - 1; + pos.col = originalCol; pos.row = bitmap.height - originalRow - 1; LOG2(" (%d,%d)", pos.col, pos.row); append_outline_pixel(&outline, pos); } - search_dir = original_dir; /* initial value */ - row = original_row; /* initial value */ - col = original_col; /* initial values */ + searchDir = originalDir; /* initial value */ + row = originalRow; /* initial value */ + col = originalCol; /* initial values */ for ( ; ; ) { - unsigned int const prev_row = row; - unsigned int const prev_col = col; + unsigned int const prevRow = row; + unsigned int const prevCol = col; /* If there is no adjacent, unmarked pixel, we can't proceed any further, so return an open outline. */ - if (!next_unmarked_pixel(&row, &col, &search_dir, bitmap, marked)) { + if (!next_unmarked_pixel(&row, &col, &searchDir, bitmap, marked)) { outline.open = true; break; } @@ -291,12 +292,12 @@ find_one_centerline(bitmap_type const bitmap, /* If we've moved to a new pixel, mark all edges of the previous pixel so that it won't be revisited. */ - if (!(prev_row == original_row && prev_col == original_col)) - mark_dir(prev_row, prev_col, search_dir, marked); - mark_dir(row, col, (search_dir + 4) % 8, marked); + if (!(prevRow == originalRow && prevCol == originalCol)) + mark_dir(prevRow, prevCol, searchDir, marked); + mark_dir(row, col, (searchDir + 4) % 8, marked); /* If we've returned to the starting pixel, we're done. */ - if (row == original_row && col == original_col) + if (row == originalRow && col == originalCol) break; @@ -308,7 +309,7 @@ find_one_centerline(bitmap_type const bitmap, append_outline_pixel(&outline, pos); } } - mark_dir(original_row, original_col, original_dir, marked); + mark_dir(originalRow, originalCol, originalDir, marked); return outline; } @@ -392,7 +393,7 @@ find_centerline_pixels(bitmap_type const bitmap, LOG2("#%u: (%sclockwise) ", O_LIST_LENGTH(outline_list), clockwise ? "" : "counter"); - outline = find_one_centerline(bitmap, dir, row, col, &marked); + outline = findOneCenterline(bitmap, dir, row, col, &marked); /* If the outline is open (i.e., we didn't return to the starting pixel), search from the starting pixel in the @@ -450,7 +451,7 @@ find_centerline_pixels(bitmap_type const bitmap, } if (okay) { partial_outline = - find_one_centerline(bitmap, dir, row, col, &marked); + findOneCenterline(bitmap, dir, row, col, &marked); concat_pixel_outline(&outline, &partial_outline); if (partial_outline.data) free(partial_outline.data); diff --git a/converter/other/pamtosvg/spline.c b/converter/other/pamtosvg/spline.c index 5bdf0c0e..61167ec4 100644 --- a/converter/other/pamtosvg/spline.c +++ b/converter/other/pamtosvg/spline.c @@ -105,11 +105,13 @@ new_spline_list_with_spline (spline_type spline) elements, since they are arrays in automatic storage. And we don't want to free the list if it was empty. */ + + void -free_spline_list (spline_list_type spline_list) -{ - if (SPLINE_LIST_DATA (spline_list) != NULL) - free (SPLINE_LIST_DATA (spline_list)); +free_spline_list(spline_list_type spline_list) { + + if (SPLINE_LIST_DATA(spline_list) != NULL) + free(SPLINE_LIST_DATA(spline_list)); } diff --git a/converter/other/pamtosvg/spline.h b/converter/other/pamtosvg/spline.h index 05a56e23..96ceab4e 100644 --- a/converter/other/pamtosvg/spline.h +++ b/converter/other/pamtosvg/spline.h @@ -21,6 +21,7 @@ typedef at_spline_type spline_type; #define START_POINT(spl) ((spl).v[0]) #define CONTROL1(spl) ((spl).v[1]) #define CONTROL2(spl) ((spl).v[2]) +#define BEG_POINT(spl) ((spl).v[0]) #define END_POINT(spl) ((spl).v[3]) #define SPLINE_DEGREE(spl) ((spl).degree) #define SPLINE_LINEARITY(spl) ((spl).linearity) diff --git a/converter/other/pamtosvg/vector.c b/converter/other/pamtosvg/vector.c index 18d6de59..7678f73a 100644 --- a/converter/other/pamtosvg/vector.c +++ b/converter/other/pamtosvg/vector.c @@ -17,137 +17,150 @@ static float acos_d (float, at_exception_type * excep); /* Given the point COORD, return the corresponding vector. */ vector_type -make_vector (const float_coord c) -{ - vector_type v; +make_vector(float_coord const c) { - v.dx = c.x; - v.dy = c.y; - v.dz = c.z; + vector_type v; + + v.dx = c.x; + v.dy = c.y; + v.dz = c.z; - return v; + return v; } + /* And the converse: given a vector, return the corresponding point. */ float_coord -vector_to_point (const vector_type v) -{ - float_coord coord; +vector_to_point(vector_type const v) { + + float_coord coord; - coord.x = v.dx; - coord.y = v.dy; - coord.z = v.dz; + coord.x = v.dx; + coord.y = v.dy; + coord.z = v.dz; - return coord; + return coord; } -float -magnitude (const vector_type v) -{ - return (float) sqrt (v.dx * v.dx + v.dy * v.dy + v.dz * v.dz); -} +float +magnitude(vector_type const v) { -vector_type -normalize (const vector_type v) -{ - vector_type new_v; - float m = magnitude (v); + return sqrt(SQR(v.dx) + SQR(v.dy) + SQR(v.dz)); +} - /* assert (m > 0.0); */ - if (m > 0.0) - { - new_v.dx = v.dx / m; - new_v.dy = v.dy / m; - new_v.dz = v.dz / m; - } - else - { - new_v.dx = v.dx; - new_v.dy = v.dy; - new_v.dz = v.dz; - } - return new_v; +vector_type +normalize(vector_type const v) { + + vector_type new_v; + float const m = magnitude(v); + + if (m > 0.0) { + new_v.dx = v.dx / m; + new_v.dy = v.dy / m; + new_v.dz = v.dz / m; + } else { + new_v.dx = v.dx; + new_v.dy = v.dy; + new_v.dz = v.dz; + } + + return new_v; } + vector_type -Vadd (const vector_type v1, const vector_type v2) -{ - vector_type new_v; +Vadd(vector_type const v1, + vector_type const v2) { + + vector_type new_v; - new_v.dx = v1.dx + v2.dx; - new_v.dy = v1.dy + v2.dy; - new_v.dz = v1.dz + v2.dz; + new_v.dx = v1.dx + v2.dx; + new_v.dy = v1.dy + v2.dy; + new_v.dz = v1.dz + v2.dz; - return new_v; + return new_v; } + float -Vdot (const vector_type v1, const vector_type v2) -{ - return v1.dx * v2.dx + v1.dy * v2.dy + v1.dz * v2.dz; +Vdot(vector_type const v1, + vector_type const v2) { + + return v1.dx * v2.dx + v1.dy * v2.dy + v1.dz * v2.dz; } + vector_type -Vmult_scalar (const vector_type v, const float r) -{ - vector_type new_v; +Vmult_scalar(vector_type const v, + float const r) { - new_v.dx = v.dx * r; - new_v.dy = v.dy * r; - new_v.dz = v.dz * r; + vector_type new_v; - return new_v; + new_v.dx = v.dx * r; + new_v.dy = v.dy * r; + new_v.dz = v.dz * r; + + return new_v; } + /* Given the IN_VECTOR and OUT_VECTOR, return the angle between them in - degrees, in the range zero to 180. */ + degrees, in the range zero to 180. +*/ float -Vangle (const vector_type in_vector, - const vector_type out_vector, - at_exception_type * exp) -{ - vector_type v1 = normalize (in_vector); - vector_type v2 = normalize (out_vector); +Vangle(vector_type const in_vector, + vector_type const out_vector, + at_exception_type * const exP) { + + vector_type const v1 = normalize(in_vector); + vector_type const v2 = normalize(out_vector); - return acos_d (Vdot (v2, v1), exp); + return acos_d(Vdot(v2, v1), exP); } + float_coord -Vadd_point (const float_coord c, const vector_type v) -{ - float_coord new_c; +Vadd_point(float_coord const c, + vector_type const v) { + + float_coord new_c; - new_c.x = c.x + v.dx; - new_c.y = c.y + v.dy; - new_c.z = c.z + v.dz; - return new_c; + new_c.x = c.x + v.dx; + new_c.y = c.y + v.dy; + new_c.z = c.z + v.dz; + + return new_c; } + float_coord -Vsubtract_point (const float_coord c, const vector_type v) -{ - float_coord new_c; +Vsubtract_point(float_coord const c, + vector_type const v) { + + float_coord new_c; - new_c.x = c.x - v.dx; - new_c.y = c.y - v.dy; - new_c.z = c.z - v.dz; - return new_c; + new_c.x = c.x - v.dx; + new_c.y = c.y - v.dy; + new_c.z = c.z - v.dz; + + return new_c; } + pm_pixelcoord Vadd_int_point(pm_pixelcoord const c, vector_type const v) { @@ -161,56 +174,73 @@ Vadd_int_point(pm_pixelcoord const c, } + vector_type -Vabs (const vector_type v) -{ - vector_type new_v; +Vabs(vector_type const v) { - new_v.dx = (float) fabs (v.dx); - new_v.dy = (float) fabs (v.dy); - new_v.dz = (float) fabs (v.dz); - return new_v; + vector_type new_v; + + new_v.dx = (float) fabs (v.dx); + new_v.dy = (float) fabs (v.dy); + new_v.dz = (float) fabs (v.dz); + + return new_v; } + /* Operations on points. */ float_coord -Padd (const float_coord coord1, const float_coord coord2) -{ - float_coord sum; +Padd(float_coord const coord1, + float_coord const coord2) { - sum.x = coord1.x + coord2.x; - sum.y = coord1.y + coord2.y; - sum.z = coord1.z + coord2.z; + float_coord sum; - return sum; + sum.x = coord1.x + coord2.x; + sum.y = coord1.y + coord2.y; + sum.z = coord1.z + coord2.z; + + return sum; } + float_coord -Pmult_scalar (const float_coord coord, const float r) -{ - float_coord answer; +Pmult_scalar(float_coord const coord, + float const r) { + + float_coord answer; - answer.x = coord.x * r; - answer.y = coord.y * r; - answer.z = coord.z * r; + answer.x = coord.x * r; + answer.y = coord.y * r; + answer.z = coord.z * r; - return answer; + return answer; } + vector_type -Psubtract (const float_coord c1, const float_coord c2) -{ - vector_type v; +Psubtract(float_coord const c1, + float_coord const c2) { + + vector_type v; - v.dx = c1.x - c2.x; - v.dy = c1.y - c2.y; - v.dz = c1.z - c2.z; + v.dx = c1.x - c2.x; + v.dy = c1.y - c2.y; + v.dz = c1.z - c2.z; - return v; + return v; +} + + + +vector_type +Pdirection(float_coord const final, + float_coord const initial) { + + return normalize(Psubtract(final, initial)); } @@ -233,23 +263,27 @@ IPsubtract(pm_pixelcoord const coord1, static float -acos_d (float v, at_exception_type * excep) -{ - float a; - - if (epsilon_equal (v, 1.0)) - v = 1.0; - else if (epsilon_equal (v, -1.0)) - v = -1.0; - - errno = 0; - a = (float) acos (v); - if (errno == ERANGE || errno == EDOM) - { - at_exception_fatal(excep, strerror(errno)); - return 0.0; - } - - - return a * (float) 180.0 / (float) M_PI; +acos_d(float const v, + at_exception_type * const excepP) { + + float vAdj; + float a; + float retval; + + if (epsilon_equal(v, 1.0)) + vAdj = 1.0; + else if (epsilon_equal(v, -1.0)) + vAdj = -1.0; + else + vAdj = v; + + errno = 0; + a = acos(vAdj); + if (errno == ERANGE || errno == EDOM) { + at_exception_fatal(excepP, strerror(errno)); + retval = 0.0; + } else + retval = a * 180.0 / M_PI; + + return retval; } diff --git a/converter/other/pamtosvg/vector.h b/converter/other/pamtosvg/vector.h index 74fb2fd2..b5c85c38 100644 --- a/converter/other/pamtosvg/vector.h +++ b/converter/other/pamtosvg/vector.h @@ -15,32 +15,58 @@ typedef struct /* Consider a point as a vector from the origin. */ -extern vector_type make_vector (const float_coord); +vector_type +make_vector(float_coord const); /* And a vector as a point, i.e., a displacement from the origin. */ -extern float_coord vector_to_point (const vector_type); +float_coord +vector_to_point(vector_type const); /* Definitions for these common operations can be found in any decent linear algebra book, and most calculus books. */ -extern float magnitude (const vector_type); -extern vector_type normalize (const vector_type); +float +magnitude(vector_type const); + +vector_type +normalize(vector_type const); + +vector_type +Vadd(vector_type const, + vector_type const); -extern vector_type Vadd (const vector_type, const vector_type); -extern float Vdot (const vector_type, const vector_type); -extern vector_type Vmult_scalar (const vector_type, const float); -extern float Vangle (const vector_type in, const vector_type out, at_exception_type * exp); +float +Vdot(vector_type const, + vector_type const); + +vector_type +Vmult_scalar(vector_type const, + float const); + +float +Vangle(vector_type const in, + vector_type const out, + at_exception_type * const exP); /* These operations could have been named `P..._vector' just as well as V..._point, so we may as well allow both names. */ + #define Padd_vector Vadd_point -extern float_coord Vadd_point - (const float_coord, const vector_type); + +float_coord +Vadd_point(float_coord const, + vector_type const); #define Psubtract_vector Vsubtract_point -extern float_coord Vsubtract_point - (const float_coord, const vector_type); + +float_coord +Vsubtract_point(float_coord const, + vector_type const); + +vector_type +Pdirection(float_coord const final, + float_coord const initial); /* This returns the rounded sum. */ #define IPadd_vector Vadd_int_point @@ -50,22 +76,28 @@ Vadd_int_point(pm_pixelcoord const c, vector_type const v); /* Take the absolute value of both components. */ -extern vector_type Vabs (const vector_type); +vector_type +Vabs(vector_type const); /* Operations on points with real coordinates. It is not orthogonal, but more convenient, to have the subtraction operator return a vector, and the addition operator return a point. */ -extern vector_type Psubtract - (const float_coord, const float_coord); +vector_type +Psubtract(float_coord const, + float_coord const); vector_type IPsubtract(pm_pixelcoord const coord1, pm_pixelcoord const coord2); /* These are heavily used in spline fitting. */ -extern float_coord Padd (const float_coord, - const float_coord); -extern float_coord Pmult_scalar (const float_coord, const float); -#endif +float_coord +Padd(float_coord const, + float_coord const); +float_coord +Pmult_scalar(float_coord const, + float const); + +#endif |