Merge lp:~valavanisalex/inkscape/fix-1156664 into lp:~inkscape.dev/inkscape/trunk

[Alex Valavanis]

This branch removes the embedded copy of Potrace (except for the handy bitmap.h macros) and links to an external installation instead.

I've also allowed Inkscape to build without Potrace being present, so this can be applied (hopefully) independently of the DevLibs update. If Potrace is not found on the user's system, then the flood and trace tools are disabled.

I've tested on Ubuntu 15.10 with and without Potrace, and using either Autotools or CMake.

I'd appreciate someone checking:
(a) does this work on Windows and OS X?
(b) is my CMake implementation sensible?

[su_v (suv-lp)]

On 2015-11-13 24:49 (+0100), Alex Valavanis wrote:
> I've tested on Ubuntu 15.10 with and without Potrace, and using
> either Autotools or CMake.
>
> I'd appreciate someone checking:
> (a) does this work on Windows and OS X?

Tested successfully with trunk r14478 (GTK2) on OS X 10.7.5 with and
without Potrace, for Autotools- as well as CMake-based build system. Not
tested specifically with osx packaging (it should not cause issues there
though - the external linked library will be copied automagically into
the app bundle, and the library paths rewritten).

Uninformed question wrt potrace: I noticed that in MacPorts (package
manager for OS X) potrace's configure options for metric units
(--enable-metric) and default page size (--enable-a4) are offered as
variants - are these only relevant for the command line tools installed
by potrace, or would different defaults somehow affect trace mode /
flood fill in Inkscape?

> (b) is my CMake implementation sensible?

I noticed that cmake does not inform the user if potrace is not found
(it does report it if found though). Maybe let users know if features
are disabled due to missing optional dependencies?

(c) Independent of build system: it might be safer to disable the
related verbs too (tool, dialog), if compiling without potrace: inkscape
e.g. crashes if launched with one of the (defunct) verbs on the command
line:

$ inkscape --verb=ToolPaintBucket

or when switching tools using keyboard shortcuts (Shift+F7).

[lp:~valavanisalex/inkscape/fix-1156664]

14456. By Alex Valavanis on 2015-11-21

Hide unused verbs if Potrace is not available

[Alex Valavanis (valavanisalex)]

(c) Hopefully fixed in r14456: The impossible verbs are disabled if Potrace is not found

[Alex Valavanis (valavanisalex)]

(a) Yes, these options (AFAIU) are only used for the Potrace command-line application. In Inkscape, we just use the API function that converts a bitmap (i.e., an array of pixels rather than a drawing in real-world units) into vector objects using the same scale.

[lp:~valavanisalex/inkscape/fix-1156664]

14457. By Alex Valavanis on 2015-11-21

Add warning about missing Potrace to CMake build

[Alex Valavanis (valavanisalex)]

(b) Added a warning about missing Potrace to the CMake build in r14457

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-10-26 22:50:52 +0000
+++ CMakeLists.txt	2015-11-21 12:39:21 +0000
@@ -100,7 +100,6 @@
 # -----------------------------------------------------------------------------
 # BAD HACKS, NEED TO INVESTIGATE MAKING THESE LESS BAD
 add_definitions(-D_FORTIFY_SOURCE=2)
-add_definitions(-DPOTRACE="potrace")
 add_definitions(-DORBIT2=1)
 add_definitions(-DHAVE_CONFIG_H)
 add_definitions(-DHAVE_CAIRO_PDF=1)  # needed for src/libnrtype/Layout-TNG.h
 
=== modified file 'CMakeScripts/DefineDependsandFlags.cmake'
--- CMakeScripts/DefineDependsandFlags.cmake	2015-10-26 22:50:52 +0000
+++ CMakeScripts/DefineDependsandFlags.cmake	2015-11-21 12:39:21 +0000
@@ -197,6 +197,17 @@
 list(APPEND INKSCAPE_LIBS ${POPT_LIBRARIES})
 add_definitions(${POPT_DEFINITIONS})
 
+find_package(Potrace)
+if(POTRACE_FOUND)
+  list(APPEND INKSCAPE_INCS_SYS ${POTRACE_INCLUDE_DIRS})
+  list(APPEND INKSCAPE_LIBS ${POTRACE_LIBRARIES})
+  set(HAVE_POTRACE ON)
+  add_definitions(-DHAVE_POTRACE)
+else(POTRACE_FOUND)
+  set(HAVE_POTRACE OFF)
+  message(STATUS "Could not locate the Potrace library headers: the Trace Bitmap and Paintbucket tools will be disabled")
+endif()
+
 if(WITH_DBUS)
 	find_package(DBus REQUIRED)
 	if(DBUS_FOUND)
 
=== added file 'CMakeScripts/Modules/FindPotrace.cmake'
--- CMakeScripts/Modules/FindPotrace.cmake	1970-01-01 00:00:00 +0000
+++ CMakeScripts/Modules/FindPotrace.cmake	2015-11-21 12:39:21 +0000
@@ -0,0 +1,62 @@
+#  POTRACE_FOUND - system has Potrace
+#  POTRACE_INCLUDE_DIRS - the Potrace include directory
+#  POTRACE_LIBRARIES - The libraries needed to use Potrace
+
+IF (POTRACE_LIBRARIES AND POTRACE_INCLUDE_DIRS)
+   # in cache already
+   SET(POTRACE_FOUND TRUE)
+ELSE (POTRACE_LIBRARIES AND POTRACE_INCLUDE_DIRS)
+   FIND_PATH (POTRACE_INCLUDE_DIR
+      NAMES
+         potracelib.h
+      PATHS
+         /usr/include
+         /usr/local/include
+	 $ENV{DEVLIBS_PATH}/include
+      PATH_SUFFIXES
+         potrace
+   )
+
+   FIND_LIBRARY (POTRACE_LIBRARY
+      NAMES
+        potrace
+        libpotrace
+      PATHS
+         /usr/lib
+         /usr/local/lib
+         $ENV{DEVLIBS_PATH}/lib
+   )
+
+   if (POTRACE_LIBRARY)
+      set (POTRACE_FOUND TRUE)
+   endif (POTRACE_LIBRARY)
+
+   set (POTRACE_INCLUDE_DIRS
+      ${POTRACE_INCLUDE_DIR}
+   )
+
+   if (POTRACE_FOUND)
+      set(POTRACE_LIBRARIES
+        ${POTRACE_LIBRARIES}
+        ${POTRACE_LIBRARY}
+      )
+   endif (POTRACE_FOUND)
+
+   if (POTRACE_INCLUDE_DIRS AND POTRACE_LIBRARIES)
+      set(POTRACE_FOUND TRUE)
+   endif (POTRACE_INCLUDE_DIRS AND POTRACE_LIBRARIES)
+
+   if (POTRACE_FOUND)
+      if (NOT Potrace_FIND_QUIETLY)
+         message(STATUS "Found Potrace: ${POTRACE_LIBRARIES}")
+      endif (NOT Potrace_FIND_QUIETLY)
+   else (POTRACE_FOUND)
+      if (Potrace_FIND_REQUIRED)
+	      message(FATAL_ERROR "Could not find potrace")
+      endif (Potrace_FIND_REQUIRED)
+   endif (POTRACE_FOUND)
+
+   # show the POTRACE_INCLUDE_DIRS and POTRACE_LIBRARIES variables only in the advanced view
+   MARK_AS_ADVANCED(POTRACE_INCLUDE_DIRS POTRACE_LIBRARIES)
+
+endif (POTRACE_LIBRARIES AND POTRACE_INCLUDE_DIRS)
 
=== modified file 'configure.ac'
--- configure.ac	2015-08-23 07:03:34 +0000
+++ configure.ac	2015-11-21 12:39:21 +0000
@@ -240,6 +240,17 @@
 	AC_DEFINE(HAVE_OPENMP, 1, [Use OpenMP])
 fi
 
+dnl ********************
+dnl Check for libpotrace
+dnl ********************
+AC_CHECK_LIB(potrace, potrace_trace, [AC_CHECK_HEADER(potracelib.h, potrace_ok=yes, potrace_ok=no)], potrace_ok=no)
+if test "x$potrace_ok" = "xyes"; then
+   LIBS="-lpotrace $LIBS"
+   AC_DEFINE(HAVE_POTRACE, 1, [Use Potrace])
+fi
+
+AM_CONDITIONAL(HAVE_POTRACE, test "x$potrace_ok" = "xyes")
+
 dnl ******************************
 dnl Check for libexif
 dnl ******************************
@@ -1192,6 +1203,7 @@
         Enable LittleCms:         ${enable_lcms}
         Enable DBUS:              ${with_dbus} 
         Enable Poppler-Cairo:     ${enable_poppler_cairo}
+	Enable Potrace:           ${potrace_ok}
         ImageMagick Magick++:     ${magick_ok}
         Libwpg:                   ${with_libwpg}
         Libvisio:                 ${with_libvisio}
 
=== modified file 'src/menus-skeleton.h'
--- src/menus-skeleton.h	2015-01-25 11:26:05 +0000
+++ src/menus-skeleton.h	2015-11-21 12:39:21 +0000
@@ -1,7 +1,9 @@
 #ifndef SEEN_MENUS_SKELETON_H
 #define SEEN_MENUS_SKELETON_H
 
-#include "config.h"
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
 
 #ifdef __cplusplus
 #undef N_
@@ -221,7 +223,11 @@
 "   <submenu name=\"" N_("_Path") "\">\n"
 "       <verb verb-id=\"ObjectToPath\" />\n"
 "       <verb verb-id=\"StrokeToPath\" />\n"
+
+#if HAVE_POTRACE
 "       <verb verb-id=\"SelectionTrace\" />\n"
+#endif
+
 "       <verb verb-id=\"SelectionPixelArt\" />\n"
 "       <separator/>\n"
 "       <verb verb-id=\"SelectionUnion\" />\n"
@@ -284,7 +290,9 @@
 "           <verb verb-id=\"TutorialsBasic\" />\n"
 "           <verb verb-id=\"TutorialsShapes\" />\n"
 "           <verb verb-id=\"TutorialsAdvanced\" />\n"
+#if HAVE_POTRACE
 "           <verb verb-id=\"TutorialsTracing\" />\n"
+#endif
 "           <verb verb-id=\"TutorialsTracingPixelArt\" />\n"
 "           <verb verb-id=\"TutorialsCalligraphy\" />\n"
 "           <verb verb-id=\"TutorialsInterpolate\" />\n"
 
=== modified file 'src/shortcuts.cpp'
--- src/shortcuts.cpp	2014-06-26 19:40:39 +0000
+++ src/shortcuts.cpp	2015-11-21 12:39:21 +0000
@@ -575,7 +575,14 @@
         }
 
         Inkscape::Verb *verb=Inkscape::Verb::getbyid(verb_name);
-        if (!verb) {
+        if (!verb
+#if !HAVE_POTRACE
+                // Squash warning about disabled features
+                && strcmp(verb_name, "ToolPaintBucket")  != 0
+                && strcmp(verb_name, "SelectionTrace")   != 0
+                && strcmp(verb_name, "PaintBucketPrefs") != 0
+#endif
+           ) {
             g_warning("Unknown verb name: %s", verb_name);
             continue;
         }
 
=== modified file 'src/trace/CMakeLists.txt'
--- src/trace/CMakeLists.txt	2015-06-08 19:01:23 +0000
+++ src/trace/CMakeLists.txt	2015-11-21 12:39:21 +0000
@@ -1,3 +1,4 @@
+if (${HAVE_POTRACE})
 
 set(trace_SRC
 	filterset.cpp
@@ -7,14 +8,7 @@
 	siox.cpp
 	trace.cpp
 
-	potrace/curve.cpp
-	potrace/decompose.cpp
-	potrace/greymap.cpp
 	potrace/inkscape-potrace.cpp
-	potrace/potracelib.cpp
-	potrace/render.cpp
-	potrace/trace.cpp
-
 
 	# -------
 	# Headers
@@ -26,19 +20,11 @@
 	siox.h
 	trace.h
 
-	potrace/auxiliary.h
 	potrace/bitmap.h
-	potrace/bitops.h
-	potrace/curve.h
-	potrace/decompose.h
-	potrace/greymap.h
 	potrace/inkscape-potrace.h
-	potrace/lists.h
-	potrace/potracelib.h
-	potrace/progress.h
-	potrace/render.h
-	potrace/trace.h
 )
 
 # add_inkscape_lib(trace_LIB "${trace_SRC}")
 add_inkscape_source("${trace_SRC}")
+
+endif()
 
=== modified file 'src/trace/Makefile_insert'
--- src/trace/Makefile_insert	2009-02-20 22:15:27 +0000
+++ src/trace/Makefile_insert	2015-11-21 12:39:21 +0000
@@ -1,5 +1,7 @@
 ## Makefile.am fragment sourced by src/Makefile.am.
 
+if HAVE_POTRACE
+
 ink_common_sources +=	            \
 	trace/pool.h                        \
 	trace/trace.h                       \
@@ -14,21 +16,8 @@
 	trace/filterset.cpp	            \
 	trace/siox.h			    \
 	trace/siox.cpp			    \
-        trace/potrace/auxiliary.h           \
-        trace/potrace/bitmap.h              \
-        trace/potrace/curve.cpp             \
-        trace/potrace/curve.h               \
-        trace/potrace/decompose.cpp         \
-        trace/potrace/decompose.h           \
-        trace/potrace/greymap.cpp           \
-        trace/potrace/greymap.h             \
-        trace/potrace/lists.h               \
-        trace/potrace/potracelib.cpp        \
-        trace/potrace/potracelib.h          \
-        trace/potrace/progress.h            \
-        trace/potrace/render.cpp            \
-        trace/potrace/render.h              \
-        trace/potrace/trace.cpp             \
-        trace/potrace/trace.h               \
+	trace/potrace/bitmap.h              \
 	trace/potrace/inkscape-potrace.cpp  \
 	trace/potrace/inkscape-potrace.h
+
+endif
 
=== removed file 'src/trace/potrace/auxiliary.h'
--- src/trace/potrace/auxiliary.h	2015-03-31 10:33:40 +0000
+++ src/trace/potrace/auxiliary.h	1970-01-01 00:00:00 +0000
@@ -1,80 +0,0 @@
-/* Copyright (C) 2001-2015 Peter Selinger.
-   This file is part of Potrace. It is free software and it is covered
-   by the GNU General Public License. See the file COPYING for details. */
-
-/* This header file collects some general-purpose macros (and static
-   inline functions) that are used in various places. */
-
-#ifndef AUXILIARY_H
-#define AUXILIARY_H
-
-#include <stdlib.h>
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-/* ---------------------------------------------------------------------- */
-/* point arithmetic */
-
-#include "potracelib.h"
-
-struct point_s {
-  long x;
-  long y;
-};
-typedef struct point_s point_t;
-
-typedef potrace_dpoint_t dpoint_t;
-
-/* convert point_t to dpoint_t */
-static inline dpoint_t dpoint(point_t p) {
-  dpoint_t res;
-  res.x = p.x;
-  res.y = p.y;
-  return res;
-}
-
-/* range over the straight line segment [a,b] when lambda ranges over [0,1] */
-static inline dpoint_t interval(double lambda, dpoint_t a, dpoint_t b) {
-  dpoint_t res;
-
-  res.x = a.x + lambda * (b.x - a.x);
-  res.y = a.y + lambda * (b.y - a.y);
-  return res;
-}
-
-/* ---------------------------------------------------------------------- */
-/* some useful macros. Note: the "mod" macro works correctly for
-   negative a. Also note that the test for a>=n, while redundant,
-   speeds up the mod function by 70% in the average case (significant
-   since the program spends about 16% of its time here - or 40%
-   without the test). The "floordiv" macro returns the largest integer
-   <= a/n, and again this works correctly for negative a, as long as
-   a,n are integers and n>0. */
-
-/* integer arithmetic */
-
-static inline int mod(int a, int n) {
-  return a>=n ? a%n : a>=0 ? a : n-1-(-1-a)%n;
-}
-
-static inline int floordiv(int a, int n) {
-  return a>=0 ? a/n : -1-(-1-a)/n;
-}
-
-/* Note: the following work for integers and other numeric types. */
-#undef sign
-#undef abs
-#undef min
-#undef max
-#undef sq
-#undef cu
-#define sign(x) ((x)>0 ? 1 : (x)<0 ? -1 : 0)
-#define abs(a) ((a)>0 ? (a) : -(a))
-#define min(a,b) ((a)<(b) ? (a) : (b))
-#define max(a,b) ((a)>(b) ? (a) : (b))
-#define sq(a) ((a)*(a))
-#define cu(a) ((a)*(a)*(a))
-
-#endif /* AUXILIARY_H */
 
=== modified file 'src/trace/potrace/bitmap.h'
--- src/trace/potrace/bitmap.h	2015-03-31 10:33:40 +0000
+++ src/trace/potrace/bitmap.h	2015-11-21 12:39:21 +0000
@@ -8,6 +8,7 @@
 #include <string.h>
 #include <stdlib.h>
 #include <errno.h>
+#include <stddef.h>
 
 /* The bitmap type is defined in potracelib.h */
 #include "potracelib.h"
@@ -28,7 +29,7 @@
 /* macros for accessing pixel at index (x,y). U* macros omit the
    bounds check. */
 
-#define bm_scanline(bm, y) ((bm)->map + (ssize_t)(y)*(ssize_t)(bm)->dy)
+#define bm_scanline(bm, y) ((bm)->map + (ptrdiff_t)(y)*(ptrdiff_t)(bm)->dy)
 #define bm_index(bm, x, y) (&bm_scanline(bm, y)[(x)/BM_WORDBITS])
 #define bm_mask(x) (BM_HIBIT >> ((x) & (BM_WORDBITS-1)))
 #define bm_range(x, a) ((int)(x) >= 0 && (int)(x) < (a))
@@ -57,10 +58,10 @@
 static inline potrace_bitmap_t *bm_new(int w, int h) {
   potrace_bitmap_t *bm;
   int dy = w == 0 ? 0 : (w - 1) / BM_WORDBITS + 1;
-  ssize_t size = (ssize_t)dy * (ssize_t)h * (ssize_t)BM_WORDSIZE;
+  ptrdiff_t size = (ptrdiff_t)dy * (ptrdiff_t)h * (ptrdiff_t)BM_WORDSIZE;
 
   /* check for overflow error */
-  if (size < 0 || size / h / dy != BM_WORDSIZE) {
+  if (size < 0 || (h != 0 && dy != 0 && size / h / dy != BM_WORDSIZE)) {
     errno = ENOMEM;
     return NULL;
   }
@@ -83,15 +84,15 @@
 /* clear the given bitmap. Set all bits to c. */
 static inline void bm_clear(potrace_bitmap_t *bm, int c) {
   /* Note: if the bitmap was created with bm_new, then it is
-     guaranteed that size will fit into the ssize_t type. */
-  ssize_t size = (ssize_t)bm->dy * (ssize_t)bm->h * (ssize_t)BM_WORDSIZE;
+     guaranteed that size will fit into the ptrdiff_t type. */
+  ptrdiff_t size = (ptrdiff_t)bm->dy * (ptrdiff_t)bm->h * (ptrdiff_t)BM_WORDSIZE;
   memset(bm->map, c ? -1 : 0, size);
 }
 
 /* duplicate the given bitmap. Return NULL on error with errno set. */
 static inline potrace_bitmap_t *bm_dup(const potrace_bitmap_t *bm) {
   potrace_bitmap_t *bm1 = bm_new(bm->w, bm->h);
-  ssize_t size = (ssize_t)bm->dy * (ssize_t)bm->h * (ssize_t)BM_WORDSIZE;
+  ptrdiff_t size = (ptrdiff_t)bm->dy * (ptrdiff_t)bm->h * (ptrdiff_t)BM_WORDSIZE;
   if (!bm1) {
     return NULL;
   }
@@ -101,8 +102,8 @@
 
 /* invert the given bitmap. */
 static inline void bm_invert(potrace_bitmap_t *bm) {
-  ssize_t i;
-  ssize_t size = (ssize_t)bm->dy * (ssize_t)bm->h;
+  ptrdiff_t i;
+  ptrdiff_t size = (ptrdiff_t)bm->dy * (ptrdiff_t)bm->h;
 
   for (i = 0; i < size; i++) {
     bm->map[i] ^= BM_ALLBITS;
 
=== removed file 'src/trace/potrace/bitops.h'
--- src/trace/potrace/bitops.h	2015-03-31 10:33:40 +0000
+++ src/trace/potrace/bitops.h	1970-01-01 00:00:00 +0000
@@ -1,83 +0,0 @@
-/* Copyright (C) 2001-2015 Peter Selinger.
-   This file is part of Potrace. It is free software and it is covered
-   by the GNU General Public License. See the file COPYING for details. */
-
-
-/* bits.h: this file defines some macros for bit manipulations. We
-   provide a generic implementation, as well as machine- and
-   compiler-specific fast implementations */
-
-/* lobit: return the position of the rightmost "1" bit of an int, or
-   32 if none. hibit: return 1 + the position of the leftmost "1" bit
-   of an int, or 0 if none. Note: these functions work on 32-bit
-   integers. */
-
-#ifndef BITOPS_H
-#define BITOPS_H
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-/* ---------------------------------------------------------------------- */
-/* machine specific macros */
-
-#if defined(HAVE_I386)
-
-static inline unsigned int lobit(unsigned int x) {
-  unsigned int res;
-  asm ("bsf	%1,%0\n\t"
-       "jnz	0f\n\t"
-       "movl	$32,%0\n"
-       "0:"
-       : "=r" (res)
-       : "r" (x)
-       : "cc");
-  return res;
-}
-
-static inline unsigned int hibit(unsigned int x) {
-  unsigned int res;					
-
-  asm ("bsr	%1,%0\n\t"
-       "jnz	0f\n\t"
-       "movl	$-1,%0\n"
-       "0:"
-       : "=r" (res)
-       : "r" (x)
-       : "cc");
-  return res+1;
-}
-
-/* ---------------------------------------------------------------------- */
-#else /* generic macros */
-
-static inline unsigned int lobit(unsigned int x) {
-  unsigned int res = 32;
-  while (x & 0xffffff) {
-    x <<= 8;
-    res -= 8;
-  }
-  while (x) {
-    x <<= 1;
-    res -= 1;
-  }
-  return res;
-}
-
-static inline unsigned int hibit(unsigned int x) {
-  unsigned int res = 0;
-  while (x > 0xff) {
-    x >>= 8;
-    res += 8;
-  }
-  while (x) {
-    x >>= 1;
-    res += 1;
-  }
-  return res;
-}
-
-#endif 
-
-#endif /* BITOPS_H */
 
=== removed file 'src/trace/potrace/curve.cpp'
--- src/trace/potrace/curve.cpp	2015-03-31 10:33:40 +0000
+++ src/trace/potrace/curve.cpp	1970-01-01 00:00:00 +0000
@@ -1,108 +0,0 @@
-/* Copyright (C) 2001-2015 Peter Selinger.
-   This file is part of Potrace. It is free software and it is covered
-   by the GNU General Public License. See the file COPYING for details. */
-
-/* private part of the path and curve data structures */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "potracelib.h"
-#include "lists.h"
-#include "curve.h"
-
-#define SAFE_CALLOC(var, n, typ) \
-  if ((var = (typ *)calloc(n, sizeof(typ))) == NULL) goto calloc_error 
-
-/* ---------------------------------------------------------------------- */
-/* allocate and free path objects */
-
-path_t *path_new(void) {
-  path_t *p = NULL;
-  privpath_t *priv = NULL;
-
-  SAFE_CALLOC(p, 1, path_t);
-  memset(p, 0, sizeof(path_t));
-  SAFE_CALLOC(priv, 1, privpath_t);
-  memset(priv, 0, sizeof(privpath_t));
-  p->priv = priv;
-  return p;
-
- calloc_error:
-  free(p);
-  free(priv);
-  return NULL;
-}
-
-/* free the members of the given curve structure. Leave errno unchanged. */
-static void privcurve_free_members(privcurve_t *curve) {
-  free(curve->tag);
-  free(curve->c);
-  free(curve->vertex);
-  free(curve->alpha);
-  free(curve->alpha0);
-  free(curve->beta);
-}
-
-/* free a path. Leave errno untouched. */
-void path_free(path_t *p) {
-  if (p) {
-    if (p->priv) {
-      free(p->priv->pt);
-      free(p->priv->lon);
-      free(p->priv->sums);
-      free(p->priv->po);
-      privcurve_free_members(&p->priv->curve);
-      privcurve_free_members(&p->priv->ocurve);
-    }
-    free(p->priv);
-    /* do not free p->fcurve ! */
-  }
-  free(p);
-}  
-
-/* free a pathlist, leaving errno untouched. */
-void pathlist_free(path_t *plist) {
-  path_t *p;
-
-  list_forall_unlink(p, plist) {
-    path_free(p);
-  }
-}
-
-/* ---------------------------------------------------------------------- */
-/* initialize and finalize curve structures */
-
-typedef dpoint_t dpoint3_t[3];
-
-/* initialize the members of the given curve structure to size m.
-   Return 0 on success, 1 on error with errno set. */
-int privcurve_init(privcurve_t *curve, int n) {
-  memset(curve, 0, sizeof(privcurve_t));
-  curve->n = n;
-  SAFE_CALLOC(curve->tag, n, int);
-  SAFE_CALLOC(curve->c, n, dpoint3_t);
-  SAFE_CALLOC(curve->vertex, n, dpoint_t);
-  SAFE_CALLOC(curve->alpha, n, double);
-  SAFE_CALLOC(curve->alpha0, n, double);
-  SAFE_CALLOC(curve->beta, n, double);
-  return 0;
-
- calloc_error:
-  free(curve->tag);
-  free(curve->c);
-  free(curve->vertex);
-  free(curve->alpha);
-  free(curve->alpha0);
-  free(curve->beta);
-  return 1;
-}
-
-/* copy private to public curve structure */
-void privcurve_to_curve(privcurve_t *pc, potrace_curve_t *c) {
-  c->n = pc->n;
-  c->tag = pc->tag;
-  c->c = pc->c;
-}
-    
 
=== removed file 'src/trace/potrace/curve.h'
--- src/trace/potrace/curve.h	2015-03-31 10:33:40 +0000
+++ src/trace/potrace/curve.h	1970-01-01 00:00:00 +0000
@@ -1,77 +0,0 @@
-/* Copyright (C) 2001-2015 Peter Selinger.
-   This file is part of Potrace. It is free software and it is covered
-   by the GNU General Public License. See the file COPYING for details. */
-
-#ifndef CURVE_H
-#define CURVE_H
-
-#include "auxiliary.h"
-
-/* vertex is c[1] for tag=POTRACE_CORNER, and the intersection of
-   .c[-1][2]..c[0] and c[1]..c[2] for tag=POTRACE_CURVETO. alpha is only
-   defined for tag=POTRACE_CURVETO and is the alpha parameter of the curve:
-   .c[-1][2]..c[0] = alpha*(.c[-1][2]..vertex), and
-   c[2]..c[1] = alpha*(c[2]..vertex).
-   Beta is so that (.beta[i])[.vertex[i],.vertex[i+1]] = .c[i][2].
-*/
-
-struct privcurve_s {
-  int n;            /* number of segments */
-  int *tag;         /* tag[n]: POTRACE_CORNER or POTRACE_CURVETO */
-  dpoint_t (*c)[3]; /* c[n][i]: control points. 
-		       c[n][0] is unused for tag[n]=POTRACE_CORNER */
-  /* the remainder of this structure is special to privcurve, and is
-     used in EPS debug output and special EPS "short coding". These
-     fields are valid only if "alphacurve" is set. */
-  int alphacurve;   /* have the following fields been initialized? */
-  dpoint_t *vertex; /* for POTRACE_CORNER, this equals c[1] */
-  double *alpha;    /* only for POTRACE_CURVETO */
-  double *alpha0;   /* "uncropped" alpha parameter - for debug output only */
-  double *beta;
-};
-typedef struct privcurve_s privcurve_t;
-
-struct sums_s {
-  double x;
-  double y;
-  double x2;
-  double xy;
-  double y2;
-};
-typedef struct sums_s sums_t;
-
-/* the path structure is filled in with information about a given path
-   as it is accumulated and passed through the different stages of the
-   Potrace algorithm. Backends only need to read the fcurve and fm
-   fields of this data structure, but debugging backends may read
-   other fields. */
-struct potrace_privpath_s {
-  int len;
-  point_t *pt;     /* pt[len]: path as extracted from bitmap */
-  int *lon;        /* lon[len]: (i,lon[i]) = longest straight line from i */
-
-  int x0, y0;      /* origin for sums */
-  sums_t *sums;    /* sums[len+1]: cache for fast summing */
-
-  int m;           /* length of optimal polygon */
-  int *po;         /* po[m]: optimal polygon */
-
-  privcurve_t curve;   /* curve[m]: array of curve elements */
-  privcurve_t ocurve;  /* ocurve[om]: array of curve elements */
-  privcurve_t *fcurve;  /* final curve: this points to either curve or
-		       ocurve. Do not free this separately. */
-};
-typedef struct potrace_privpath_s potrace_privpath_t;
-
-/* shorter names */
-typedef potrace_privpath_t privpath_t;
-typedef potrace_path_t path_t;
-
-path_t *path_new(void);
-void path_free(path_t *p);
-void pathlist_free(path_t *plist);
-int privcurve_init(privcurve_t *curve, int n);
-void privcurve_to_curve(privcurve_t *pc, potrace_curve_t *c);
-
-#endif /* CURVE_H */
-
 
=== removed file 'src/trace/potrace/decompose.cpp'
--- src/trace/potrace/decompose.cpp	2015-03-31 10:33:40 +0000
+++ src/trace/potrace/decompose.cpp	1970-01-01 00:00:00 +0000
@@ -1,511 +0,0 @@
-/* Copyright (C) 2001-2015 Peter Selinger.
-   This file is part of Potrace. It is free software and it is covered
-   by the GNU General Public License. See the file COPYING for details. */
-
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <limits.h>
-
-#include "potracelib.h"
-#include "curve.h"
-#include "lists.h"
-#include "bitmap.h"
-#include "decompose.h"
-#include "progress.h"
-
-/* ---------------------------------------------------------------------- */
-/* deterministically and efficiently hash (x,y) into a pseudo-random bit */
-
-static inline int detrand(int x, int y) {
-  unsigned int z;
-  static const unsigned char t[256] = { 
-    /* non-linear sequence: constant term of inverse in GF(8), 
-       mod x^8+x^4+x^3+x+1 */
-    0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 
-    0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 
-    0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 
-    1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 
-    0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 
-    0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 
-    0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 
-    0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 
-    1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 
-    0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 
-    1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 
-  };
-
-  /* 0x04b3e375 and 0x05a8ef93 are chosen to contain every possible
-     5-bit sequence */
-  z = ((0x04b3e375 * x) ^ y) * 0x05a8ef93;
-  z = t[z & 0xff] ^ t[(z>>8) & 0xff] ^ t[(z>>16) & 0xff] ^ t[(z>>24) & 0xff];
-  return z;
-}
-
-/* ---------------------------------------------------------------------- */
-/* auxiliary bitmap manipulations */
-
-/* set the excess padding to 0 */
-static void bm_clearexcess(potrace_bitmap_t *bm) {
-  if (bm->w % BM_WORDBITS != 0) {
-    potrace_word mask = BM_ALLBITS << (BM_WORDBITS - (bm->w % BM_WORDBITS));
-    for (int y=0; y<bm->h; y++) {
-      *bm_index(bm, bm->w, y) &= mask;
-    }
-  }
-}
-
-struct bbox_s {
-  int x0, x1, y0, y1;    /* bounding box */
-};
-typedef struct bbox_s bbox_t;
-
-/* clear the bm, assuming the bounding box is set correctly (faster
-   than clearing the whole bitmap) */
-static void clear_bm_with_bbox(potrace_bitmap_t *bm, bbox_t *bbox) {
-  int imin = (bbox->x0 / BM_WORDBITS);
-  int imax = ((bbox->x1 + BM_WORDBITS-1) / BM_WORDBITS);
-  int i, y;
-
-  for (y=bbox->y0; y<bbox->y1; y++) {
-    for (i=imin; i<imax; i++) {
-      bm_scanline(bm, y)[i] = 0;
-    }
-  }
-}
-
-/* ---------------------------------------------------------------------- */
-/* auxiliary functions */
-
-/* return the "majority" value of bitmap bm at intersection (x,y). We
-   assume that the bitmap is balanced at "radius" 1.  */
-static int majority(potrace_bitmap_t *bm, int x, int y) {
-  int i, a, ct;
-
-  for (i=2; i<5; i++) { /* check at "radius" i */
-    ct = 0;
-    for (a=-i+1; a<=i-1; a++) {
-      ct += BM_GET(bm, x+a, y+i-1) ? 1 : -1;
-      ct += BM_GET(bm, x+i-1, y+a-1) ? 1 : -1;
-      ct += BM_GET(bm, x+a-1, y-i) ? 1 : -1;
-      ct += BM_GET(bm, x-i, y+a) ? 1 : -1;
-    }
-    if (ct>0) {
-      return 1;
-    } else if (ct<0) {
-      return 0;
-    }
-  }
-  return 0;
-}
-
-/* ---------------------------------------------------------------------- */
-/* decompose image into paths */
-
-/* efficiently invert bits [x,infty) and [xa,infty) in line y. Here xa
-   must be a multiple of BM_WORDBITS. */
-static void xor_to_ref(potrace_bitmap_t *bm, int x, int y, int xa) {
-  int xhi = x & -BM_WORDBITS;
-  int xlo = x & (BM_WORDBITS-1);  /* = x % BM_WORDBITS */
-  int i;
-  
-  if (xhi<xa) {
-    for (i = xhi; i < xa; i+=BM_WORDBITS) {
-      *bm_index(bm, i, y) ^= BM_ALLBITS;
-    }
-  } else {
-    for (i = xa; i < xhi; i+=BM_WORDBITS) {
-      *bm_index(bm, i, y) ^= BM_ALLBITS;
-    }
-  }
-  /* note: the following "if" is needed because x86 treats a<<b as
-     a<<(b&31). I spent hours looking for this bug. */
-  if (xlo) {
-    *bm_index(bm, xhi, y) ^= (BM_ALLBITS << (BM_WORDBITS - xlo));
-  }
-}
-
-/* a path is represented as an array of points, which are thought to
-   lie on the corners of pixels (not on their centers). The path point
-   (x,y) is the lower left corner of the pixel (x,y). Paths are
-   represented by the len/pt components of a path_t object (which
-   also stores other information about the path) */
-
-/* xor the given pixmap with the interior of the given path. Note: the
-   path must be within the dimensions of the pixmap. */
-static void xor_path(potrace_bitmap_t *bm, path_t *p) {
-  int xa, x, y, k, y1;
-
-  if (p->priv->len <= 0) {  /* a path of length 0 is silly, but legal */
-    return;
-  }
-
-  y1 = p->priv->pt[p->priv->len-1].y;
-
-  xa = p->priv->pt[0].x & -BM_WORDBITS;
-  for (k=0; k<p->priv->len; k++) {
-    x = p->priv->pt[k].x;
-    y = p->priv->pt[k].y;
-
-    if (y != y1) {
-      /* efficiently invert the rectangle [x,xa] x [y,y1] */
-      xor_to_ref(bm, x, min(y,y1), xa);
-      y1 = y;
-    }
-  }
-}
-
-/* Find the bounding box of a given path. Path is assumed to be of
-   non-zero length. */
-static void setbbox_path(bbox_t *bbox, path_t *p) {
-  int x, y;
-  int k;
-
-  bbox->y0 = INT_MAX;
-  bbox->y1 = 0;
-  bbox->x0 = INT_MAX;
-  bbox->x1 = 0;
-
-  for (k=0; k<p->priv->len; k++) {
-    x = p->priv->pt[k].x;
-    y = p->priv->pt[k].y;
-
-    if (x < bbox->x0) {
-      bbox->x0 = x;
-    }
-    if (x > bbox->x1) {
-      bbox->x1 = x;
-    }
-    if (y < bbox->y0) {
-      bbox->y0 = y;
-    }
-    if (y > bbox->y1) {
-      bbox->y1 = y;
-    }
-  }
-}
-
-/* compute a path in the given pixmap, separating black from white.
-   Start path at the point (x0,x1), which must be an upper left corner
-   of the path. Also compute the area enclosed by the path. Return a
-   new path_t object, or NULL on error (note that a legitimate path
-   cannot have length 0). Sign is required for correct interpretation
-   of turnpolicies. */
-static path_t *findpath(potrace_bitmap_t *bm, int x0, int y0, int sign, int turnpolicy) {
-  int x, y, dirx, diry, len, size, area;
-  int c, d, tmp;
-  point_t *pt, *pt1;
-  path_t *p = NULL;
-
-  x = x0;
-  y = y0;
-  dirx = 0;
-  diry = -1;
-
-  len = size = 0;
-  pt = NULL;
-  area = 0;
-  
-  while (1) {
-    /* add point to path */
-    if (len>=size) {
-      size += 100;
-      size = (int)(1.3 * size);
-      pt1 = (point_t *)realloc(pt, size * sizeof(point_t));
-      if (!pt1) {
-	goto error;
-      }
-      pt = pt1;
-    }
-    pt[len].x = x;
-    pt[len].y = y;
-    len++;
-    
-    /* move to next point */
-    x += dirx;
-    y += diry;
-    area += x*diry;
-    
-    /* path complete? */
-    if (x==x0 && y==y0) {
-      break;
-    }
-    
-    /* determine next direction */
-    c = BM_GET(bm, x + (dirx+diry-1)/2, y + (diry-dirx-1)/2);
-    d = BM_GET(bm, x + (dirx-diry-1)/2, y + (diry+dirx-1)/2);
-    
-    if (c && !d) {               /* ambiguous turn */
-      if (turnpolicy == POTRACE_TURNPOLICY_RIGHT
-	  || (turnpolicy == POTRACE_TURNPOLICY_BLACK && sign == '+')
-	  || (turnpolicy == POTRACE_TURNPOLICY_WHITE && sign == '-')
-	  || (turnpolicy == POTRACE_TURNPOLICY_RANDOM && detrand(x,y))
-	  || (turnpolicy == POTRACE_TURNPOLICY_MAJORITY && majority(bm, x, y))
-	  || (turnpolicy == POTRACE_TURNPOLICY_MINORITY && !majority(bm, x, y))) {
-	tmp = dirx;              /* right turn */
-	dirx = diry;
-	diry = -tmp;
-      } else {
-	tmp = dirx;              /* left turn */
-	dirx = -diry;
-	diry = tmp;
-      }
-    } else if (c) {              /* right turn */
-      tmp = dirx;
-      dirx = diry;
-      diry = -tmp;
-    } else if (!d) {             /* left turn */
-      tmp = dirx;
-      dirx = -diry;
-      diry = tmp;
-    }
-  } /* while this path */
-
-  /* allocate new path object */
-  p = path_new();
-  if (!p) {
-    goto error;
-  }
-
-  p->priv->pt = pt;
-  p->priv->len = len;
-  p->area = area;
-  p->sign = sign;
-
-  return p;
- 
- error:
-   free(pt);
-   return NULL; 
-}
-
-/* Give a tree structure to the given path list, based on "insideness"
-   testing. I.e., path A is considered "below" path B if it is inside
-   path B. The input pathlist is assumed to be ordered so that "outer"
-   paths occur before "inner" paths. The tree structure is stored in
-   the "childlist" and "sibling" components of the path_t
-   structure. The linked list structure is also changed so that
-   negative path components are listed immediately after their
-   positive parent.  Note: some backends may ignore the tree
-   structure, others may use it e.g. to group path components. We
-   assume that in the input, point 0 of each path is an "upper left"
-   corner of the path, as returned by bm_to_pathlist. This makes it
-   easy to find an "interior" point. The bm argument should be a
-   bitmap of the correct size (large enough to hold all the paths),
-   and will be used as scratch space. Return 0 on success or -1 on
-   error with errno set. */
-
-static void pathlist_to_tree(path_t *plist, potrace_bitmap_t *bm) {
-  path_t *p, *p1;
-  path_t *heap, *heap1;
-  path_t *cur;
-  path_t *head;
-  path_t **plist_hook;          /* for fast appending to linked list */
-  path_t **hook_in, **hook_out; /* for fast appending to linked list */
-  bbox_t bbox;
-  
-  bm_clear(bm, 0);
-
-  /* save original "next" pointers */
-  list_forall(p, plist) {
-    p->sibling = p->next;
-    p->childlist = NULL;
-  }
-  
-  heap = plist;
-
-  /* the heap holds a list of lists of paths. Use "childlist" field
-     for outer list, "next" field for inner list. Each of the sublists
-     is to be turned into a tree. This code is messy, but it is
-     actually fast. Each path is rendered exactly once. We use the
-     heap to get a tail recursive algorithm: the heap holds a list of
-     pathlists which still need to be transformed. */
-
-  while (heap) {
-    /* unlink first sublist */
-    cur = heap;
-    heap = heap->childlist;
-    cur->childlist = NULL;
-  
-    /* unlink first path */
-    head = cur;
-    cur = cur->next;
-    head->next = NULL;
-
-    /* render path */
-    xor_path(bm, head);
-    setbbox_path(&bbox, head);
-
-    /* now do insideness test for each element of cur; append it to
-       head->childlist if it's inside head, else append it to
-       head->next. */
-    hook_in=&head->childlist;
-    hook_out=&head->next;
-    list_forall_unlink(p, cur) {
-      if (p->priv->pt[0].y <= bbox.y0) {
-	list_insert_beforehook(p, hook_out);
-	/* append the remainder of the list to hook_out */
-	*hook_out = cur;
-	break;
-      }
-      if (BM_GET(bm, p->priv->pt[0].x, p->priv->pt[0].y-1)) {
-	list_insert_beforehook(p, hook_in);
-      } else {
-	list_insert_beforehook(p, hook_out);
-      }
-    }
-
-    /* clear bm */
-    clear_bm_with_bbox(bm, &bbox);
-
-    /* now schedule head->childlist and head->next for further
-       processing */
-    if (head->next) {
-      head->next->childlist = heap;
-      heap = head->next;
-    }
-    if (head->childlist) {
-      head->childlist->childlist = heap;
-      heap = head->childlist;
-    }
-  }
-  
-  /* copy sibling structure from "next" to "sibling" component */
-  p = plist;
-  while (p) {
-    p1 = p->sibling;
-    p->sibling = p->next;
-    p = p1;
-  }
-
-  /* reconstruct a new linked list ("next") structure from tree
-     ("childlist", "sibling") structure. This code is slightly messy,
-     because we use a heap to make it tail recursive: the heap
-     contains a list of childlists which still need to be
-     processed. */
-  heap = plist;
-  if (heap) {
-    heap->next = NULL;  /* heap is a linked list of childlists */
-  }
-  plist = NULL;
-  plist_hook = &plist;
-  while (heap) {
-    heap1 = heap->next;
-    for (p=heap; p; p=p->sibling) {
-      /* p is a positive path */
-      /* append to linked list */
-      list_insert_beforehook(p, plist_hook);
-      
-      /* go through its children */
-      for (p1=p->childlist; p1; p1=p1->sibling) {
-	/* append to linked list */
-	list_insert_beforehook(p1, plist_hook);
-	/* append its childlist to heap, if non-empty */
-	if (p1->childlist) {
-	  list_append(path_t, heap1, p1->childlist);
-	}
-      }
-    }
-    heap = heap1;
-  }
-
-  return;
-}
-
-/* find the next set pixel in a row <= y. Pixels are searched first
-   left-to-right, then top-down. In other words, (x,y)<(x',y') if y>y'
-   or y=y' and x<x'. If found, return 0 and store pixel in
-   (*xp,*yp). Else return 1. Note that this function assumes that
-   excess bytes have been cleared with bm_clearexcess. */
-static int findnext(potrace_bitmap_t *bm, int *xp, int *yp) {
-  int x;
-  int y;
-  int x0;
-
-  x0 = (*xp) & ~(BM_WORDBITS-1);
-
-  for (y=*yp; y>=0; y--) {
-    for (x=x0; x<bm->w; x+=BM_WORDBITS) {
-      if (*bm_index(bm, x, y)) {
-	while (!BM_GET(bm, x, y)) {
-	  x++;
-	}
-	/* found */
-	*xp = x;
-	*yp = y;
-	return 0;
-      }
-    }
-    x0 = 0;
-  }
-  /* not found */
-  return 1;
-}
-
-/* Decompose the given bitmap into paths. Returns a linked list of
-   path_t objects with the fields len, pt, area, sign filled
-   in. Returns 0 on success with plistp set, or -1 on error with errno
-   set. */
-
-int bm_to_pathlist(const potrace_bitmap_t *bm, path_t **plistp, const potrace_param_t *param, progress_t *progress) {
-  int x;
-  int y;
-  path_t *p;
-  path_t *plist = NULL;  /* linked list of path objects */
-  path_t **plist_hook = &plist;  /* used to speed up appending to linked list */
-  potrace_bitmap_t *bm1 = NULL;
-  int sign;
-
-  bm1 = bm_dup(bm);
-  if (!bm1) {
-    goto error;
-  }
-
-  /* be sure the byte padding on the right is set to 0, as the fast
-     pixel search below relies on it */
-  bm_clearexcess(bm1);
-
-  /* iterate through components */
-  x = 0;
-  y = bm1->h - 1;
-  while (findnext(bm1, &x, &y) == 0) { 
-    /* calculate the sign by looking at the original */
-    sign = BM_GET(bm, x, y) ? '+' : '-';
-
-    /* calculate the path */
-    p = findpath(bm1, x, y+1, sign, param->turnpolicy);
-    if (p==NULL) {
-      goto error;
-    }
-
-    /* update buffered image */
-    xor_path(bm1, p);
-
-    /* if it's a turd, eliminate it, else append it to the list */
-    if (p->area <= param->turdsize) {
-      path_free(p);
-    } else {
-      list_insert_beforehook(p, plist_hook);
-    }
-
-    if (bm1->h > 0) { /* to be sure */
-      progress_update(1-y/(double)bm1->h, progress);
-    }
-  }
-
-  pathlist_to_tree(plist, bm1);
-  bm_free(bm1);
-  *plistp = plist;
-
-  progress_update(1.0, progress);
-
-  return 0;
-
- error:
-  bm_free(bm1);
-  list_forall_unlink(p, plist) {
-    path_free(p);
-  }
-  return -1;
-}
 
=== removed file 'src/trace/potrace/decompose.h'
--- src/trace/potrace/decompose.h	2015-03-31 10:33:40 +0000
+++ src/trace/potrace/decompose.h	1970-01-01 00:00:00 +0000
@@ -1,16 +0,0 @@
-/* Copyright (C) 2001-2015 Peter Selinger.
-   This file is part of Potrace. It is free software and it is covered
-   by the GNU General Public License. See the file COPYING for details. */
-
-
-#ifndef DECOMPOSE_H
-#define DECOMPOSE_H
-
-#include "potracelib.h"
-#include "progress.h"
-#include "curve.h"
-
-int bm_to_pathlist(const potrace_bitmap_t *bm, path_t **plistp, const potrace_param_t *param, progress_t *progress);
-
-#endif /* DECOMPOSE_H */
-
 
=== removed file 'src/trace/potrace/greymap.cpp'
--- src/trace/potrace/greymap.cpp	2015-03-31 10:33:40 +0000
+++ src/trace/potrace/greymap.cpp	1970-01-01 00:00:00 +0000
@@ -1,941 +0,0 @@
-/* Copyright (C) 2001-2015 Peter Selinger.
-   This file is part of Potrace. It is free software and it is covered
-   by the GNU General Public License. See the file COPYING for details. */
-
-
-/* Routines for manipulating greymaps, including reading pgm files. We
-   only deal with greymaps of depth 8 bits. */
-
-#include <stdlib.h>
-#include <string.h>
-#include <math.h>
-#include <errno.h>
-
-#include "greymap.h"
-#include "bitops.h"
-
-#define INTBITS (8*sizeof(int))
-
-#define mod(a,n) ((a)>=(n) ? (a)%(n) : (a)>=0 ? (a) : (n)-1-(-1-(a))%(n))
-
-static int gm_readbody_pnm(FILE *f, greymap_t **gmp, int magic);
-static int gm_readbody_bmp(FILE *f, greymap_t **gmp);
-
-/* ---------------------------------------------------------------------- */
-/* basic greymap routines */
-
-/* return new un-initialized greymap. NULL with errno on error.
-   Assumes w, h >= 0. */
-greymap_t *gm_new(int w, int h) {
-  greymap_t *gm;
-  ssize_t size = (ssize_t)w * (ssize_t)h * (ssize_t)sizeof(signed short int);
-  
-  /* check for overflow error */
-  if (size < 0 || size / w / h != sizeof(signed short int)) {
-    errno = ENOMEM;
-    return NULL;
-  }
-
-  gm = (greymap_t *) malloc(sizeof(greymap_t));
-  if (!gm) {
-    return NULL;
-  }
-  gm->w = w;
-  gm->h = h;
-  gm->map = (signed short int *) malloc(size);
-  if (!gm->map) {
-    free(gm);
-    return NULL;
-  }
-  return gm;
-}
-
-/* free the given greymap */
-void gm_free(greymap_t *gm) {
-  if (gm) {
-    free(gm->map);
-  }
-  free(gm);
-}
-
-/* duplicate the given greymap. Return NULL on error with errno set. */
-greymap_t *gm_dup(greymap_t *gm) {
-  greymap_t *gm1 = gm_new(gm->w, gm->h);
-  if (!gm1) {
-    return NULL;
-  }
-  memcpy(gm1->map, gm->map, gm->w*gm->h*sizeof(signed short int));
-  return gm1;
-}
-
-/* clear the given greymap to color b. */
-void gm_clear(greymap_t *gm, int b) {
-  if (b==0) {
-    memset(gm->map, 0, gm->w*gm->h*sizeof(signed short int));
-  } else {
-    for (int i=0; i<gm->w*gm->h; i++) {
-      gm->map[i] = b;
-    }
-  }    
-}
-
-/* ---------------------------------------------------------------------- */
-/* routines for reading pnm streams */
-
-/* read next character after whitespace and comments. Return EOF on
-   end of file or error. */
-static int fgetc_ws(FILE *f) {
-  int c;
-
-  while (1) {
-    c = fgetc(f);
-    if (c=='#') {
-      while (1) {
-	c = fgetc(f);
-	if (c=='\n' || c==EOF) {
-	  break;
-	}
-      }
-    }
-    /* space, tab, line feed, carriage return, form-feed */
-    if (c!=' ' && c!='\t' && c!='\r' && c!='\n' && c!=12) {
-      return c;
-    }
-  }
-}
-
-/* skip whitespace and comments, then read a non-negative decimal
-   number from a stream. Return -1 on EOF. Tolerate other errors (skip
-   bad characters). Do not the read any characters following the
-   number (put next character back into the stream) */
-
-static int readnum(FILE *f) {
-  int c;
-  int acc;
-
-  /* skip whitespace and comments */
-  while (1) {
-    c = fgetc_ws(f);
-    if (c==EOF) {
-      return -1;
-    }
-    if (c>='0' && c<='9') {
-      break;
-    }
-  }
-
-  /* first digit is already in c */
-  acc = c-'0';
-  while (1) {
-    c = fgetc(f);
-    if (c==EOF) {
-      break;
-    }
-    if (c<'0' || c>'9') {
-      ungetc(c, f);
-      break;
-    }
-    acc *= 10;
-    acc += c-'0';
-  }
-  return acc;
-}
-
-/* similar to readnum, but read only a single 0 or 1, and do not read
-   any characters after it. */
-
-static int readbit(FILE *f) {
-  int c;
-
-  /* skip whitespace and comments */
-  while (1) {
-    c = fgetc_ws(f);
-    if (c==EOF) {
-      return -1;
-    }
-    if (c>='0' && c<='1') {
-      break;
-    }
-  }
-
-  return c-'0';
-}
-
-/* ---------------------------------------------------------------------- */
-
-/* read a PNM stream: P1-P6 format (see pnm(5)), or a BMP stream, and
-   convert the output to a greymap. Return greymap in *gmp. Return 0
-   on success, -1 on error with errno set, -2 on bad file format (with
-   error message in gm_read_error), and 1 on premature end of file, -3
-   on empty file (including files with only whitespace and comments),
-   -4 if wrong magic number. If the return value is >=0, *gmp is
-   valid. */
-
-char const *gm_read_error = NULL;
-
-int gm_read(FILE *f, greymap_t **gmp) {
-  int magic[2];
-
-  /* read magic number. We ignore whitespace and comments before the
-     magic, for the benefit of concatenated files in P1-P3 format.
-     Multiple P1-P3 images in a single file are not formally allowed
-     by the PNM standard, but there is no harm in being lenient. */
-
-  magic[0] = fgetc_ws(f);
-  if (magic[0] == EOF) {
-    /* files which contain only comments and whitespace count as "empty" */
-    return -3;
-  } 
-  magic[1] = fgetc(f);
-  if (magic[0] == 'P' && magic[1] >= '1' && magic[1] <= '6') {
-    return gm_readbody_pnm(f, gmp, magic[1]);
-  }
-  if (magic[0] == 'B' && magic[1] == 'M') {
-    return gm_readbody_bmp(f, gmp);
-  }
-  return -4;
-}
-
-/* ---------------------------------------------------------------------- */
-/* read PNM format */
-
-/* read PNM stream after magic number. Return values as for gm_read */
-static int gm_readbody_pnm(FILE *f, greymap_t **gmp, int magic) {
-  greymap_t *gm;
-  int x, y, i, j, b, b1, sum;
-  int bpr; /* bytes per row (as opposed to 4*gm->c) */
-  int w, h, max;
-
-  gm = NULL;
-
-  w = readnum(f);
-  if (w<0) {
-    goto format_error;
-  }
-
-  h = readnum(f);
-  if (h<0) {
-    goto format_error;
-  }
-
-  /* allocate greymap */
-  gm = gm_new(w, h);
-  if (!gm) {
-    return -1;
-  }
-
-  /* zero it out */
-  gm_clear(gm, 0);
-
-  switch (magic) {
-  default: 
-    /* not reached */
-    goto format_error;  
-
-  case '1':
-    /* read P1 format: PBM ascii */
-    
-    for (y=h-1; y>=0; y--) {
-      for (x=0; x<w; x++) {
-	b = readbit(f);
-	if (b<0) {
-	  goto eof;
-	}
-	GM_UPUT(gm, x, y, b ? 0 : 255);
-      }
-    }
-    break;
-
-  case '2':
-    /* read P2 format: PGM ascii */
-    
-    max = readnum(f);
-    if (max<1) {
-      goto format_error;
-    }
-    
-    for (y=h-1; y>=0; y--) {
-      for (x=0; x<w; x++) {
-        b = readnum(f);
-        if (b<0) {
-          goto eof;
-        }
-        GM_UPUT(gm, x, y, b*255/max);
-      }
-    }
-    break;
-
-  case '3':
-    /* read P3 format: PPM ascii */
-    
-    max = readnum(f);
-    if (max<1) {
-      goto format_error;
-    }
-    
-    for (y=h-1; y>=0; y--) {
-      for (x=0; x<w; x++) {
-	sum = 0;
-	for (i=0; i<3; i++) {
-	  b = readnum(f);
-	  if (b<0) {
-	    goto eof;
-	  }
-	  sum += b;
-	}
-        GM_UPUT(gm, x, y, sum*(255/3)/max);
-      }
-    }
-    break;
-
-  case '4':
-    /* read P4 format: PBM raw */
-
-    b = fgetc(f);  /* read single white-space character after height */
-    if (b==EOF) {
-      goto format_error;
-    }
-
-    bpr = (w+7)/8;
-
-    for (y=h-1; y>=0; y--) {
-      for (i=0; i<bpr; i++) {
-	b = fgetc(f);
-	if (b==EOF) {
-	  goto eof;
-	}
-	for (j=0; j<8; j++) {
-	  GM_PUT(gm, i*8+j, y, b & (0x80 >> j) ? 0 : 255);
-	}
-      }
-    }
-    break;
-
-  case '5':
-    /* read P5 format: PGM raw */
-
-    max = readnum(f);
-    if (max<1) {
-      goto format_error;
-    }
-
-    b = fgetc(f);  /* read single white-space character after max */
-    if (b==EOF) {
-      goto format_error;
-    }
-
-    for (y=h-1; y>=0; y--) {
-      for (x=0; x<w; x++) {
-        b = fgetc(f);
-        if (b==EOF)
-          goto eof;
-        if (max>=256) {
-          b <<= 8;
-          b1 = fgetc(f);
-          if (b1==EOF)
-            goto eof;
-          b |= b1;
-        }
-        GM_UPUT(gm, x, y, b*255/max);
-      }
-    }
-    break;
-
-  case '6':
-    /* read P6 format: PPM raw */
-
-    max = readnum(f);
-    if (max<1) {
-      goto format_error;
-    }
-
-    b = fgetc(f);  /* read single white-space character after max */
-    if (b==EOF) {
-      goto format_error;
-    }
-
-    for (y=h-1; y>=0; y--) {
-      for (x=0; x<w; x++) {
-        sum = 0;
-        for (i=0; i<3; i++) {
-          b = fgetc(f);
-          if (b==EOF) {
-            goto eof;
-	  }
-          if (max>=256) {
-            b <<= 8;
-            b1 = fgetc(f);
-            if (b1==EOF)
-              goto eof;
-            b |= b1;
-          }
-          sum += b;
-        }
-        GM_UPUT(gm, x, y, sum*(255/3)/max);
-      }
-    }
-    break;
-  }
-
-  *gmp = gm;
-  return 0;
-
- eof:
-  *gmp = gm;
-  return 1;
-
- format_error:
-  gm_free(gm);
-  if (magic == '1' || magic == '4') {
-    gm_read_error = "invalid pbm file";
-  } else if (magic == '2' || magic == '5') {
-    gm_read_error = "invalid pgm file";
-  } else {
-    gm_read_error = "invalid ppm file";
-  }
-  return -2;
-}
-
-/* ---------------------------------------------------------------------- */
-/* read BMP format */
-
-struct bmp_info_s {
-  unsigned int FileSize;
-  unsigned int reserved;
-  unsigned int DataOffset;
-  unsigned int InfoSize;
-  unsigned int w;              /* width */
-  unsigned int h;              /* height */
-  unsigned int Planes;
-  unsigned int bits;           /* bits per sample */
-  unsigned int comp;           /* compression mode */
-  unsigned int ImageSize;
-  unsigned int XpixelsPerM;
-  unsigned int YpixelsPerM;
-  unsigned int ncolors;        /* number of colors in palette */
-  unsigned int ColorsImportant;
-  unsigned int RedMask;
-  unsigned int GreenMask;
-  unsigned int BlueMask;
-  unsigned int AlphaMask;
-  unsigned int ctbits;         /* sample size for color table */
-  int topdown;                 /* top-down mode? */
-};
-typedef struct bmp_info_s bmp_info_t;
-
-/* auxiliary */
-
-static int bmp_count = 0; /* counter for byte padding */
-static int bmp_pos = 0;   /* counter from start of BMP data */
-
-/* read n-byte little-endian integer. Return 1 on EOF or error, else
-   0. Assume n<=4. */
-static int bmp_readint(FILE *f, int n, unsigned int *p) {
-  int i;
-  unsigned int sum = 0;
-  int b;
-
-  for (i=0; i<n; i++) {
-    b = fgetc(f);
-    if (b==EOF) {
-      return 1;
-    }
-    sum += b << (8*i);
-  }
-  bmp_count += n;
-  bmp_pos += n;
-  *p = sum;
-  return 0;
-}
-
-/* reset padding boundary */
-static void bmp_pad_reset(void) {
-  bmp_count = 0;
-}
-
-/* read padding bytes to 4-byte boundary. Return 1 on EOF or error,
-   else 0. */
-static int bmp_pad(FILE *f) {
-  int c, i, b;
-
-  c = (-bmp_count) & 3;
-  for (i=0; i<c; i++) {
-    b = fgetc(f);
-    if (b==EOF) {
-      return 1;
-    }
-  }
-  bmp_pos += c;
-  bmp_count = 0;
-  return 0;
-}
-  
-/* forward to the new file position. Return 1 on EOF or error, else 0 */
-static int bmp_forward(FILE *f, int pos) {
-  int b;
-
-  while (bmp_pos < pos) {
-    b = fgetc(f);
-    if (b==EOF) {
-      return 1;
-    }
-    bmp_pos++;
-    bmp_count++;
-  }
-  return 0;
-}
-
-#define TRY(x) if (x) goto try_error
-#define TRY_EOF(x) if (x) goto eof
-
-/* correct y-coordinate for top-down format */
-#define ycorr(y) (bmpinfo.topdown ? bmpinfo.h-1-y : y)
-
-/* read BMP stream after magic number. Return values as for gm_read.
-   We choose to be as permissive as possible, since there are many
-   programs out there which produce BMP. For instance, ppmtobmp can
-   produce codings with anywhere from 1-8 or 24 bits per sample,
-   although most specifications only allow 1,4,8,24,32. We can also
-   read both the old and new OS/2 BMP formats in addition to the
-   Windows BMP format. */
-static int gm_readbody_bmp(FILE *f, greymap_t **gmp) {
-  bmp_info_t bmpinfo;
-  int *coltable;
-  unsigned int b, c;
-  unsigned int i, j;
-  greymap_t *gm;
-  unsigned int x, y;
-  int col[2];
-  unsigned int bitbuf;
-  unsigned int n;
-  unsigned int redshift, greenshift, blueshift;
-
-  gm_read_error = NULL;
-  gm = NULL;
-  coltable = NULL;
-
-  bmp_pos = 2;  /* set file position */
-
-  /* file header (minus magic number) */
-  TRY(bmp_readint(f, 4, &bmpinfo.FileSize));
-  TRY(bmp_readint(f, 4, &bmpinfo.reserved));
-  TRY(bmp_readint(f, 4, &bmpinfo.DataOffset));
-
-  /* info header */
-  TRY(bmp_readint(f, 4, &bmpinfo.InfoSize));
-  if (bmpinfo.InfoSize == 40 || bmpinfo.InfoSize == 64
-      || bmpinfo.InfoSize == 108 || bmpinfo.InfoSize == 124) {
-    /* Windows or new OS/2 format */
-    bmpinfo.ctbits = 32; /* sample size in color table */
-    TRY(bmp_readint(f, 4, &bmpinfo.w));
-    TRY(bmp_readint(f, 4, &bmpinfo.h));
-    TRY(bmp_readint(f, 2, &bmpinfo.Planes));
-    TRY(bmp_readint(f, 2, &bmpinfo.bits));
-    TRY(bmp_readint(f, 4, &bmpinfo.comp));
-    TRY(bmp_readint(f, 4, &bmpinfo.ImageSize));
-    TRY(bmp_readint(f, 4, &bmpinfo.XpixelsPerM));
-    TRY(bmp_readint(f, 4, &bmpinfo.YpixelsPerM));
-    TRY(bmp_readint(f, 4, &bmpinfo.ncolors));
-    TRY(bmp_readint(f, 4, &bmpinfo.ColorsImportant));
-    if (bmpinfo.InfoSize >= 108) { /* V4 and V5 bitmaps */
-      TRY(bmp_readint(f, 4, &bmpinfo.RedMask));
-      TRY(bmp_readint(f, 4, &bmpinfo.GreenMask));
-      TRY(bmp_readint(f, 4, &bmpinfo.BlueMask));
-      TRY(bmp_readint(f, 4, &bmpinfo.AlphaMask));
-    }
-    if (bmpinfo.w > 0x7fffffff) {
-      goto format_error;
-    }
-    if (bmpinfo.h > 0x7fffffff) {
-      bmpinfo.h = (-bmpinfo.h) & 0xffffffff;
-      bmpinfo.topdown = 1;
-    } else {
-      bmpinfo.topdown = 0;
-    }
-    if (bmpinfo.h > 0x7fffffff) {
-      goto format_error;
-    }
-  } else if (bmpinfo.InfoSize == 12) {
-    /* old OS/2 format */
-    bmpinfo.ctbits = 24; /* sample size in color table */
-    TRY(bmp_readint(f, 2, &bmpinfo.w));
-    TRY(bmp_readint(f, 2, &bmpinfo.h));
-    TRY(bmp_readint(f, 2, &bmpinfo.Planes));
-    TRY(bmp_readint(f, 2, &bmpinfo.bits));
-    bmpinfo.comp = 0;
-    bmpinfo.ncolors = 0;
-    bmpinfo.topdown = 0;
-  } else {
-    goto format_error;
-  }
-
-  if (bmpinfo.comp == 3 && bmpinfo.InfoSize < 108) {
-    /* bitfield feature is only understood with V4 and V5 format */
-    goto format_error;
-  }
-
-  /* forward to color table (e.g., if bmpinfo.InfoSize == 64) */
-  TRY(bmp_forward(f, 14+bmpinfo.InfoSize));
-
-  if (bmpinfo.Planes != 1) {
-    gm_read_error = "cannot handle bmp planes";
-    goto format_error;  /* can't handle planes */
-  }
-  
-  if (bmpinfo.ncolors == 0) {
-    bmpinfo.ncolors = 1 << bmpinfo.bits;
-  }
-
-  /* color table, present only if bmpinfo.bits <= 8. */
-  if (bmpinfo.bits <= 8) {
-    coltable = (int *) calloc(bmpinfo.ncolors, sizeof(int));
-    if (!coltable) {
-      goto std_error;
-    }
-    /* NOTE: since we are reading a greymap, we can immediately convert
-       the color table entries to grey values. */
-    for (i=0; i<bmpinfo.ncolors; i++) {
-      TRY(bmp_readint(f, bmpinfo.ctbits/8, &c));
-      c = ((c>>16) & 0xff) + ((c>>8) & 0xff) + (c & 0xff);
-      coltable[i] = c/3;
-    }
-  }
-
-  /* forward to data */
-  if (bmpinfo.InfoSize != 12) { /* not old OS/2 format */
-    TRY(bmp_forward(f, bmpinfo.DataOffset));
-  }
-
-  /* allocate greymap */
-  gm = gm_new(bmpinfo.w, bmpinfo.h);
-  if (!gm) {
-    goto std_error;
-  }
-  
-  /* zero it out */
-  gm_clear(gm, 0);
-
-  switch (bmpinfo.bits + 0x100*bmpinfo.comp) {
-    
-  default:
-    goto format_error;
-    break;
-    
-  case 0x001:  /* monochrome palette */
-
-    /* raster data */
-    for (y=0; y<bmpinfo.h; y++) {
-      bmp_pad_reset();
-      for (i=0; 8*i<bmpinfo.w; i++) {
-	TRY_EOF(bmp_readint(f, 1, &b));
-	for (j=0; j<8; j++) {
-	  GM_PUT(gm, i*8+j, ycorr(y), b & (0x80 >> j) ? coltable[1] : coltable[0]);
-	}
-      }
-      TRY(bmp_pad(f));
-    }
-    break;
-   
-  case 0x002:  /* 2-bit to 8-bit palettes */
-  case 0x003: 
-  case 0x004: 
-  case 0x005: 
-  case 0x006: 
-  case 0x007: 
-  case 0x008:
-    for (y=0; y<bmpinfo.h; y++) {
-      bmp_pad_reset();
-      bitbuf = 0;  /* bit buffer: bits in buffer are high-aligned */
-      n = 0;       /* number of bits currently in bitbuffer */
-      for (x=0; x<bmpinfo.w; x++) {
-	if (n < bmpinfo.bits) {
-	  TRY_EOF(bmp_readint(f, 1, &b));
-	  bitbuf |= b << (INTBITS - 8 - n);
-	  n += 8;
-	}
-	b = bitbuf >> (INTBITS - bmpinfo.bits);
-	bitbuf <<= bmpinfo.bits;
-	n -= bmpinfo.bits;
-	GM_UPUT(gm, x, ycorr(y), coltable[b]);
-      }
-      TRY(bmp_pad(f));
-    }
-    break;
-
-  case 0x010:  /* 16-bit encoding */
-    /* can't do this format because it is not well-documented and I
-       don't have any samples */
-    gm_read_error = "cannot handle bmp 16-bit coding";
-    goto format_error;
-    break;
-
-  case 0x018:  /* 24-bit encoding */
-  case 0x020:  /* 32-bit encoding */
-    for (y=0; y<bmpinfo.h; y++) {
-      bmp_pad_reset();
-      for (x=0; x<bmpinfo.w; x++) {
-        TRY_EOF(bmp_readint(f, bmpinfo.bits/8, &c));
-	c = ((c>>16) & 0xff) + ((c>>8) & 0xff) + (c & 0xff);
-        GM_UPUT(gm, x, ycorr(y), c/3);
-      }
-      TRY(bmp_pad(f));
-    }
-    break;
-
-  case 0x320:  /* 32-bit encoding with bitfields */
-    redshift = lobit(bmpinfo.RedMask);
-    greenshift = lobit(bmpinfo.GreenMask);
-    blueshift = lobit(bmpinfo.BlueMask);
-
-    for (y=0; y<bmpinfo.h; y++) {
-      bmp_pad_reset();
-      for (x=0; x<bmpinfo.w; x++) {
-        TRY_EOF(bmp_readint(f, bmpinfo.bits/8, &c));
-	c = ((c & bmpinfo.RedMask) >> redshift) + ((c & bmpinfo.GreenMask) >> greenshift) + ((c & bmpinfo.BlueMask) >> blueshift);
-        GM_UPUT(gm, x, ycorr(y), c/3);
-      }
-      TRY(bmp_pad(f));
-    }
-    break;
-
-  case 0x204:  /* 4-bit runlength compressed encoding (RLE4) */
-    x = 0;
-    y = 0;
-    while (1) {
-      TRY_EOF(bmp_readint(f, 1, &b)); /* opcode */
-      TRY_EOF(bmp_readint(f, 1, &c)); /* argument */
-      if (b>0) {
-	/* repeat count */
-	col[0] = coltable[(c>>4) & 0xf];
-	col[1] = coltable[c & 0xf];
-	for (i=0; i<b && x<bmpinfo.w; i++) {
-	  if (x>=bmpinfo.w) {
-	    x=0;
-	    y++;
-	  }
-	  if (y>=bmpinfo.h) {
-	    break;
-	  }
-	  GM_UPUT(gm, x, ycorr(y), col[i&1]);
-	  x++;
-	}
-      } else if (c == 0) {
-	/* end of line */
-	y++;
-	x = 0;
-      } else if (c == 1) {
-	/* end of greymap */
-	break;
-      } else if (c == 2) {
-	/* "delta": skip pixels in x and y directions */
-	TRY_EOF(bmp_readint(f, 1, &b)); /* x offset */
-	TRY_EOF(bmp_readint(f, 1, &c)); /* y offset */
-	x += b;
-	y += c;
-      } else {
-	/* verbatim segment */
-	for (i=0; i<c; i++) {
-	  if ((i&1)==0) {
-	    TRY_EOF(bmp_readint(f, 1, &b));
-	  }
-	  if (x>=bmpinfo.w) {
-	    x=0;
-	    y++;
-	  }
-	  if (y>=bmpinfo.h) {
-	    break;
-	  }
-	  GM_PUT(gm, x, ycorr(y), coltable[(b>>(4-4*(i&1))) & 0xf]);
-	  x++;
-	}
-	if ((c+1) & 2) {
-	  /* pad to 16-bit boundary */
-	  TRY_EOF(bmp_readint(f, 1, &b));
-	}
-      }
-    }
-    break;
-
-  case 0x108:  /* 8-bit runlength compressed encoding (RLE8) */
-    x = 0;
-    y = 0;
-    while (1) {
-      TRY_EOF(bmp_readint(f, 1, &b)); /* opcode */
-      TRY_EOF(bmp_readint(f, 1, &c)); /* argument */
-      if (b>0) {
-	/* repeat count */
-	for (i=0; i<b; i++) {
-	  if (x>=bmpinfo.w) {
-	    x=0;
-	    y++;
-	  }
-	  if (y>=bmpinfo.h) {
-	    break;
-	  }
-	  GM_UPUT(gm, x, ycorr(y), coltable[c]);
-	  x++;
-	}
-      } else if (c == 0) {
-	/* end of line */
-	y++;
-	x = 0;
-      } else if (c == 1) {
-	/* end of greymap */
-	break;
-      } else if (c == 2) {
-	/* "delta": skip pixels in x and y directions */
-	TRY_EOF(bmp_readint(f, 1, &b)); /* x offset */
-	TRY_EOF(bmp_readint(f, 1, &c)); /* y offset */
-	x += b;
-	y += c;
-      } else {
-	/* verbatim segment */
-	for (i=0; i<c; i++) {
-	  TRY_EOF(bmp_readint(f, 1, &b));
-          if (x>=bmpinfo.w) {
-            x=0;
-            y++;
-          }
-          if (y>=bmpinfo.h) {
-            break;
-          }
-	  GM_PUT(gm, x, ycorr(y), coltable[b]);
-	  x++;
-	}
-	if (c & 1) {
-	  /* pad input to 16-bit boundary */
-	  TRY_EOF(bmp_readint(f, 1, &b));
-	}
-      }
-    }
-    break;
-
-  } /* switch */
-
-  /* skip any potential junk after the data section, but don't
-     complain in case EOF is encountered */
-  bmp_forward(f, bmpinfo.FileSize);
-
-  free(coltable);
-  *gmp = gm;
-  return 0;
-
- eof:
-  free(coltable);
-  *gmp = gm;
-  return 1;
-
- format_error:
- try_error:
-  free(coltable);
-  free(gm);
-  if (!gm_read_error) {
-    gm_read_error = "invalid bmp file";
-  }
-  return -2;
-
- std_error:
-  free(coltable);
-  free(gm);
-  return -1;
-}
-
-/* ---------------------------------------------------------------------- */
-
-/* write a pgm stream, either P2 or (if raw != 0) P5 format. Include
-   one-line comment if non-NULL. Mode determines how out-of-range
-   color values are converted. Gamma is the desired gamma correction,
-   if any (set to 2.2 if the image is to look optimal on a CRT monitor,
-   2.8 for LCD). Set to 1.0 for no gamma correction */
-
-int gm_writepgm(FILE *f, greymap_t *gm, char *comment, int raw, int mode, double gamma) {
-  int x, y, v;
-  int gammatable[256];
-  
-  /* prepare gamma correction lookup table */
-  if (gamma != 1.0) {
-    gammatable[0] = 0;
-    for (v=1; v<256; v++) {
-      gammatable[v] = (int)(255 * exp(log(v/255.0)/gamma) + 0.5);
-    }
-  } else {
-    for (v=0; v<256; v++) {
-      gammatable[v] = v;
-    }
-  }  
-
-  fprintf(f, raw ? "P5\n" : "P2\n");
-  if (comment && *comment) {
-    fprintf(f, "# %s\n", comment);
-  }
-  fprintf(f, "%d %d 255\n", gm->w, gm->h);
-  for (y=gm->h-1; y>=0; y--) {
-    for (x=0; x<gm->w; x++) {
-      v = GM_UGET(gm, x, y);
-      if (mode == GM_MODE_NONZERO) {
-	if (v > 255) {
-	  v = 510 - v;
-	}
-	if (v < 0) {
-	  v = 0;
-	}
-      } else if (mode == GM_MODE_ODD) {
-	v = mod(v, 510);
-	if (v > 255) {
-	  v = 510 - v;
-	}
-      } else if (mode == GM_MODE_POSITIVE) {
-	if (v < 0) {
-	  v = 0;
-	} else if (v > 255) {
-	  v = 255;
-	}
-      } else if (mode == GM_MODE_NEGATIVE) {
-	v = 510 - v;
-	if (v < 0) {
-	  v = 0;
-	} else if (v > 255) {
-	  v = 255;
-	}
-      }
-      v = gammatable[v];
-      
-      if (raw) {
-	fputc(v, f);
-      } else {
-	fprintf(f, x == gm->w-1 ? "%d\n" : "%d ", v);
-      }	  
-    }
-  }
-  return 0;
-}
-
-/* ---------------------------------------------------------------------- */
-/* output - for primitive debugging purposes only! */
-
-/* print greymap to screen */
-int gm_print(FILE *f, greymap_t *gm) {
-  int x, y;
-  int xx, yy;
-  int d, t;
-  int sw, sh;
-
-  sw = gm->w < 79 ? gm->w : 79;
-  sh = gm->w < 79 ? gm->h : gm->h*sw*44/(79*gm->w);
-
-  for (yy=sh-1; yy>=0; yy--) {
-    for (xx=0; xx<sw; xx++) {
-      d=0;
-      t=0;
-      for (x=xx*gm->w/sw; x<(xx+1)*gm->w/sw; x++) {
-	for (y=yy*gm->h/sh; y<(yy+1)*gm->h/sh; y++) {
-	  d += GM_GET(gm, x, y);
-	  t += 256;
-	}
-      }
-      fputc("*#=- "[5*d/t], f);  /* what a cute trick :) */
-    }
-    fputc('\n', f);
-  }
-  return 0;
-}
 
=== removed file 'src/trace/potrace/greymap.h'
--- src/trace/potrace/greymap.h	2015-03-31 10:33:40 +0000
+++ src/trace/potrace/greymap.h	1970-01-01 00:00:00 +0000
@@ -1,58 +0,0 @@
-/* Copyright (C) 2001-2015 Peter Selinger.
-   This file is part of Potrace. It is free software and it is covered
-   by the GNU General Public License. See the file COPYING for details. */
-
-
-#ifndef GREYMAP_H
-#define GREYMAP_H
-
-#include <stdio.h>
-#include <stdlib.h>
-
-/* internal format for greymaps. Note: in this format, rows are
-   ordered from bottom to top. The pixels in each row are given from
-   left to right. */
-
-struct greymap_s {
-  int w;                 /* width, in pixels */
-  int h;                 /* height, in pixels */
-  signed short int *map;    /* raw data, w*h values */
-};
-typedef struct greymap_s greymap_t;
-
-/* macros for accessing pixel at index (x,y). Note that the origin is
-   in the *lower* left corner. U* macros omit the bounds check. */
-
-#define gm_index(gm, x, y) (&(gm)->map[(x)+(y)*(ssize_t)(gm)->w])
-#define gm_safe(gm, x, y) ((int)(x)>=0 && (int)(x)<(gm)->w && (int)(y)>=0 && (int)(y)<(gm)->h)
-#define gm_bound(x, m) ((x)<0 ? 0 : (x)>=(m) ? (m)-1 : (x))
-#define GM_UGET(gm, x, y) (*gm_index(gm, x, y))
-#define GM_UINC(gm, x, y, b) (*gm_index(gm, x, y) += (short int)(b))
-#define GM_UINV(gm, x, y) (*gm_index(gm, x, y) = 255 - *gm_index(gm, x, y))
-#define GM_UPUT(gm, x, y, b) (*gm_index(gm, x, y) = (short int)(b))
-#define GM_GET(gm, x, y) (gm_safe(gm, x, y) ? GM_UGET(gm, x, y) : 0)
-#define GM_INC(gm, x, y, b) (gm_safe(gm, x, y) ? GM_UINC(gm, x, y, b) : 0)
-#define GM_INV(gm, x, y) (gm_safe(gm, x, y) ? GM_UINV(gm, x, y) : 0)
-#define GM_PUT(gm, x, y, b) (gm_safe(gm, x, y) ? GM_UPUT(gm, x, y, b) : 0)
-#define GM_BGET(gm, x, y) GM_UGET(gm, gm_bound(x, gm->w), gm_bound(y, gm->h))
-
-/* modes for cutting off out-of-range values. The following names
-   refer to winding numbers. I.e., make a pixel black if winding
-   number is nonzero, odd, or positive, respectively. We assume that 0
-   winding number corresponds to white (255). */
-#define GM_MODE_NONZERO 1
-#define GM_MODE_ODD 2
-#define GM_MODE_POSITIVE 3
-#define GM_MODE_NEGATIVE 4
-
-extern char const *gm_read_error;
-
-greymap_t *gm_new(int w, int h);
-greymap_t *gm_dup(greymap_t *gm);
-void gm_free(greymap_t *gm);
-void gm_clear(greymap_t *gm, int b);
-int gm_read(FILE *f, greymap_t **gmp);
-int gm_writepgm(FILE *f, greymap_t *gm, char *comment, int raw, int mode, double gamma);
-int gm_print(FILE *f, greymap_t *gm);
-
-#endif /* GREYMAP_H */
 
=== modified file 'src/trace/potrace/inkscape-potrace.cpp'
--- src/trace/potrace/inkscape-potrace.cpp	2015-06-22 19:16:52 +0000
+++ src/trace/potrace/inkscape-potrace.cpp	2015-11-21 12:39:21 +0000
@@ -29,7 +29,6 @@
 #include "message-stack.h"
 #include <sp-path.h>
 #include <svg/path-string.h>
-#include "curve.h"
 #include "bitmap.h"
 
 using Glib::ustring;
@@ -128,7 +127,7 @@
 
 
 /**
- *  Recursively descend the path_t node tree, writing paths in SVG
+ *  Recursively descend the potrace_path_t node tree, writing paths in SVG
  *  format into the output stream.  The Point vector is used to prevent
  *  redundant paths.  Returns number of paths processed.
  */
@@ -144,7 +143,7 @@
         //g_message("node->fm:%d\n", node->fm);
         if (!curve->n)
             continue;
-        dpoint_t *pt = curve->c[curve->n - 1];
+        const potrace_dpoint_t *pt = curve->c[curve->n - 1];
         double x0 = 0.0;
         double y0 = 0.0;
         double x1 = 0.0;
@@ -192,7 +191,7 @@
             }
         data.closePath();
 
-        for (path_t *child=node->childlist; child ; child=child->sibling)
+        for (potrace_path_t *child=node->childlist; child ; child=child->sibling)
             {
             nodeCount += writePaths(engine, child, data, points);
             }
 
=== modified file 'src/trace/potrace/inkscape-potrace.h'
--- src/trace/potrace/inkscape-potrace.h	2012-02-29 01:16:51 +0000
+++ src/trace/potrace/inkscape-potrace.h	2015-11-21 12:39:21 +0000
@@ -18,7 +18,7 @@
 #define __INKSCAPE_POTRACE_H__
 
 #include <trace/trace.h>
-#include "potracelib.h"
+#include <potracelib.h>
 
 struct GrayMap_def;
 typedef GrayMap_def GrayMap;
 
=== removed file 'src/trace/potrace/lists.h'
--- src/trace/potrace/lists.h	2015-03-31 10:33:40 +0000
+++ src/trace/potrace/lists.h	1970-01-01 00:00:00 +0000
@@ -1,285 +0,0 @@
-/* Copyright (C) 2001-2015 Peter Selinger.
-   This file is part of Potrace. It is free software and it is covered
-   by the GNU General Public License. See the file COPYING for details. */
-
-
-#ifndef _PS_LISTS_H
-#define _PS_LISTS_H
-
-/* here we define some general list macros. Because they are macros,
-   they should work on any datatype with a "->next" component. Some of
-   them use a "hook". If elt and list are of type t* then hook is of
-   type t**. A hook stands for an insertion point in the list, i.e.,
-   either before the first element, or between two elements, or after
-   the last element. If an operation "sets the hook" for an element,
-   then the hook is set to just before the element. One can insert
-   something at a hook. One can also unlink at a hook: this means,
-   unlink the element just after the hook. By "to unlink", we mean the
-   element is removed from the list, but not deleted. Thus, it and its
-   components still need to be freed. */
-
-/* Note: these macros are somewhat experimental. Only the ones that
-   are actually *used* have been tested. So be careful to test any
-   that you use. Looking at the output of the preprocessor, "gcc -E"
-   (possibly piped though "indent"), might help too. Also: these
-   macros define some internal (local) variables that start with
-   "_". */
-
-/* we enclose macro definitions whose body consists of more than one
-   statement in MACRO_BEGIN and MACRO_END, rather than '{' and '}'.  The
-   reason is that we want to be able to use the macro in a context
-   such as "if (...) macro(...); else ...". If we didn't use this obscure
-   trick, we'd have to omit the ";" in such cases. */
-
-#define MACRO_BEGIN do {
-#define MACRO_END   } while (0)
-
-/* ---------------------------------------------------------------------- */
-/* macros for singly-linked lists */
-
-/* traverse list. At the end, elt is set to NULL. */
-#define list_forall(elt, list)   for (elt=list; elt!=NULL; elt=elt->next)
-
-/* set elt to the first element of list satisfying boolean condition
-   c, or NULL if not found */
-#define list_find(elt, list, c) \
-  MACRO_BEGIN list_forall(elt, list) if (c) break; MACRO_END
-
-/* like forall, except also set hook for elt. */
-#define list_forall2(elt, list, hook) \
-  for (elt=list, hook=&list; elt!=NULL; hook=&elt->next, elt=elt->next)
-
-/* same as list_find, except also set hook for elt. */
-#define list_find2(elt, list, c, hook) \
-  MACRO_BEGIN list_forall2(elt, list, hook) if (c) break; MACRO_END
-
-/* same, except only use hook. */
-#define _list_forall_hook(list, hook) \
-  for (hook=&list; *hook!=NULL; hook=&(*hook)->next)
-
-/* same, except only use hook. Note: c may only refer to *hook, not elt. */
-#define _list_find_hook(list, c, hook) \
-  MACRO_BEGIN _list_forall_hook(list, hook) if (c) break; MACRO_END
-
-/* insert element after hook */
-#define list_insert_athook(elt, hook) \
-  MACRO_BEGIN elt->next = *hook; *hook = elt; MACRO_END
-
-/* insert element before hook */
-#define list_insert_beforehook(elt, hook) \
-  MACRO_BEGIN elt->next = *hook; *hook = elt; hook=&elt->next; MACRO_END
-
-/* unlink element after hook, let elt be unlinked element, or NULL.
-   hook remains. */
-#define list_unlink_athook(list, elt, hook) \
-  MACRO_BEGIN \
-  elt = hook ? *hook : NULL; if (elt) { *hook = elt->next; elt->next = NULL; }\
-  MACRO_END
-
-/* unlink the specific element, if it is in the list. Otherwise, set
-   elt to NULL */
-#define list_unlink(listtype, list, elt)      \
-  MACRO_BEGIN  	       	       	       	      \
-  listtype **_hook;			      \
-  _list_find_hook(list, *_hook==elt, _hook);  \
-  list_unlink_athook(list, elt, _hook);	      \
-  MACRO_END
-
-/* prepend elt to list */
-#define list_prepend(list, elt) \
-  MACRO_BEGIN elt->next = list; list = elt; MACRO_END
-
-/* append elt to list. */
-#define list_append(listtype, list, elt)     \
-  MACRO_BEGIN                                \
-  listtype **_hook;                          \
-  _list_forall_hook(list, _hook) {}          \
-  list_insert_athook(elt, _hook);            \
-  MACRO_END
-
-/* unlink the first element that satisfies the condition. */
-#define list_unlink_cond(listtype, list, elt, c)     \
-  MACRO_BEGIN                                        \
-  listtype **_hook;			  	     \
-  list_find2(elt, list, c, _hook);                   \
-  list_unlink_athook(list, elt, _hook);              \
-  MACRO_END
-
-/* let elt be the nth element of the list, starting to count from 0.
-   Return NULL if out of bounds.   */
-#define list_nth(elt, list, n)                                \
-  MACRO_BEGIN                                                 \
-  int _x;  /* only evaluate n once */                         \
-  for (_x=(n), elt=list; _x && elt; _x--, elt=elt->next) {}   \
-  MACRO_END
-
-/* let elt be the nth element of the list, starting to count from 0.
-   Return NULL if out of bounds.   */
-#define list_nth_hook(elt, list, n, hook)                     \
-  MACRO_BEGIN                                                 \
-  int _x;  /* only evaluate n once */                         \
-  for (_x=(n), elt=list, hook=&list; _x && elt; _x--, hook=&elt->next, elt=elt->next) {}   \
-  MACRO_END
-
-/* set n to the length of the list */
-#define list_length(listtype, list, n)                   \
-  MACRO_BEGIN          	       	       	       	       	 \
-  listtype *_elt;   			 		 \
-  n=0;					 		 \
-  list_forall(_elt, list) 		 		 \
-    n++;				 		 \
-  MACRO_END
-
-/* set n to the index of the first element satisfying cond, or -1 if
-   none found. Also set elt to the element, or NULL if none found. */
-#define list_index(list, n, elt, c)                      \
-  MACRO_BEGIN				 		 \
-  n=0;					 		 \
-  list_forall(elt, list) {		 		 \
-    if (c) break;			 		 \
-    n++;				 		 \
-  }					 		 \
-  if (!elt)				 		 \
-    n=-1;				 		 \
-  MACRO_END
-
-/* set n to the number of elements in the list that satisfy condition c */
-#define list_count(list, n, elt, c)                      \
-  MACRO_BEGIN				 		 \
-  n=0;					 		 \
-  list_forall(elt, list) {		 		 \
-    if (c) n++;				 		 \
-  }                                                      \
-  MACRO_END
-
-/* let elt be each element of the list, unlinked. At the end, set list=NULL. */
-#define list_forall_unlink(elt, list) \
-  for (elt=list; elt ? (list=elt->next, elt->next=NULL), 1 : 0; elt=list)
-
-/* reverse a list (efficient) */
-#define list_reverse(listtype, list)            \
-  MACRO_BEGIN				 	\
-  listtype *_list1=NULL, *elt;			\
-  list_forall_unlink(elt, list) 		\
-    list_prepend(_list1, elt);			\
-  list = _list1;				\
-  MACRO_END
-
-/* insert the element ELT just before the first element TMP of the
-   list for which COND holds. Here COND must be a condition of ELT and
-   TMP.  Typical usage is to insert an element into an ordered list:
-   for instance, list_insert_ordered(listtype, list, elt, tmp,
-   elt->size <= tmp->size).  Note: if we give a "less than or equal"
-   condition, the new element will be inserted just before a sequence
-   of equal elements. If we give a "less than" condition, the new
-   element will be inserted just after a list of equal elements.
-   Note: it is much more efficient to construct a list with
-   list_prepend and then order it with list_merge_sort, than to
-   construct it with list_insert_ordered. */
-#define list_insert_ordered(listtype, list, elt, tmp, cond) \
-  MACRO_BEGIN                                               \
-  listtype **_hook;                                         \
-  _list_find_hook(list, (tmp=*_hook, (cond)), _hook);       \
-  list_insert_athook(elt, _hook);                           \
-  MACRO_END
-
-/* sort the given list, according to the comparison condition.
-   Typical usage is list_sort(listtype, list, a, b, a->size <
-   b->size).  Note: if we give "less than or equal" condition, each
-   segment of equal elements will be reversed in order. If we give a
-   "less than" condition, each segment of equal elements will retain
-   the original order. The latter is slower but sometimes
-   prettier. Average running time: n*n/2. */
-#define list_sort(listtype, list, a, b, cond)            \
-  MACRO_BEGIN                                            \
-  listtype *_newlist=NULL;                               \
-  list_forall_unlink(a, list)                            \
-    list_insert_ordered(listtype, _newlist, a, b, cond); \
-  list = _newlist;                                       \
-  MACRO_END
-
-/* a much faster sort algorithm (merge sort, n log n worst case). It
-   is required that the list type has an additional, unused next1
-   component. Note there is no curious reversal of order of equal
-   elements as for list_sort. */
-
-#define list_mergesort(listtype, list, a, b, cond)              \
-  MACRO_BEGIN						        \
-  listtype *_elt, **_hook1;				    	\
-							    	\
-  for (_elt=list; _elt; _elt=_elt->next1) {			\
-    _elt->next1 = _elt->next;				    	\
-    _elt->next = NULL;					    	\
-  }							    	\
-  do {			                               	    	\
-    _hook1 = &(list);				    	    	\
-    while ((a = *_hook1) != NULL && (b = a->next1) != NULL ) {  \
-      _elt = b->next1;					    	\
-      _list_merge_cond(listtype, a, b, cond, *_hook1);      	\
-      _hook1 = &((*_hook1)->next1);			    	\
-      *_hook1 = _elt;				            	\
-    }							    	\
-  } while (_hook1 != &(list));                                 	\
-  MACRO_END
-
-/* merge two sorted lists. Store result at &result */
-#define _list_merge_cond(listtype, a, b, cond, result)   \
-  MACRO_BEGIN                                            \
-  listtype **_hook;					 \
-  _hook = &(result);					 \
-  while (1) {                                            \
-     if (a==NULL) {					 \
-       *_hook = b;					 \
-       break;						 \
-     } else if (b==NULL) {				 \
-       *_hook = a;					 \
-       break;						 \
-     } else if (cond) {					 \
-       *_hook = a;					 \
-       _hook = &(a->next);				 \
-       a = a->next;					 \
-     } else {						 \
-       *_hook = b;					 \
-       _hook = &(b->next);				 \
-       b = b->next;					 \
-     }							 \
-  }							 \
-  MACRO_END
-
-/* ---------------------------------------------------------------------- */
-/* macros for doubly-linked lists */
-
-#define dlist_append(head, end, elt)                    \
-  MACRO_BEGIN  	       	       	       	       	       	 \
-  elt->prev = end;					 \
-  elt->next = NULL;					 \
-  if (end) {						 \
-    end->next = elt;					 \
-  } else {  						 \
-    head = elt;						 \
-  }	    						 \
-  end = elt;						 \
-  MACRO_END
-
-/* let elt be each element of the list, unlinked. At the end, set list=NULL. */
-#define dlist_forall_unlink(elt, head, end) \
-  for (elt=head; elt ? (head=elt->next, elt->next=NULL, elt->prev=NULL), 1 : (end=NULL, 0); elt=head)
-
-/* unlink the first element of the list */
-#define dlist_unlink_first(head, end, elt)               \
-  MACRO_BEGIN				       	       	 \
-  elt = head;						 \
-  if (head) {						 \
-    head = head->next;					 \
-    if (head) {						 \
-      head->prev = NULL;				 \
-    } else {						 \
-      end = NULL;					 \
-    }    						 \
-    elt->prev = NULL;					 \
-    elt->next = NULL;					 \
-  }							 \
-  MACRO_END
-
-#endif /* _PS_LISTS_H */
-
 
=== removed file 'src/trace/potrace/potracelib.cpp'
--- src/trace/potrace/potracelib.cpp	2015-03-31 10:33:40 +0000
+++ src/trace/potrace/potracelib.cpp	1970-01-01 00:00:00 +0000
@@ -1,128 +0,0 @@
-/* Copyright (C) 2001-2015 Peter Selinger.
-   This file is part of Potrace. It is free software and it is covered
-   by the GNU General Public License. See the file COPYING for details. */
-
-#include <stdlib.h>
-#include <string.h>
-#include <glib.h>
-
-#include "potracelib.h"
-#include "inkscape-version.h"
-#include "curve.h"
-#include "decompose.h"
-#include "trace.h"
-#include "progress.h"
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-/* default parameters */
-static const potrace_param_t param_default = {
-  2,                             /* turdsize */
-  POTRACE_TURNPOLICY_MINORITY,   /* turnpolicy */
-  1.0,                           /* alphamax */
-  1,                             /* opticurve */
-  0.2,                           /* opttolerance */
-  {
-    NULL,                        /* callback function */
-    NULL,                        /* callback data */
-    0.0, 1.0,                    /* progress range */
-    0.0,                         /* granularity */
-  },
-};
-
-/* Return a fresh copy of the set of default parameters, or NULL on
-   failure with errno set. */
-potrace_param_t *potrace_param_default(void) {
-  potrace_param_t *p;
-
-  p = (potrace_param_t *) malloc(sizeof(potrace_param_t));
-  if (!p) {
-    return NULL;
-  }
-  memcpy(p, &param_default, sizeof(potrace_param_t));
-  return p;
-}
-
-/* On success, returns a Potrace state st with st->status ==
-   POTRACE_STATUS_OK. On failure, returns NULL if no Potrace state
-   could be created (with errno set), or returns an incomplete Potrace
-   state (with st->status == POTRACE_STATUS_INCOMPLETE, and with errno
-   set). Complete or incomplete Potrace state can be freed with
-   potrace_state_free(). */
-potrace_state_t *potrace_trace(const potrace_param_t *param, const potrace_bitmap_t *bm) {
-  int r;
-  path_t *plist = NULL;
-  potrace_state_t *st;
-  progress_t prog;
-  progress_t subprog;
-  
-  /* prepare private progress bar state */
-  prog.callback = param->progress.callback;
-  prog.data = param->progress.data;
-  prog.min = param->progress.min;
-  prog.max = param->progress.max;
-  prog.epsilon = param->progress.epsilon;
-  prog.d_prev = param->progress.min;
-
-  /* allocate state object */
-  st = (potrace_state_t *)malloc(sizeof(potrace_state_t));
-  if (!st) {
-    return NULL;
-  }
-
-  progress_subrange_start(0.0, 0.1, &prog, &subprog);
-
-  /* process the image */
-  r = bm_to_pathlist(bm, &plist, param, &subprog);
-  if (r) {
-    free(st);
-    return NULL;
-  }
-
-  st->status = POTRACE_STATUS_OK;
-  st->plist = plist;
-  st->priv = NULL;  /* private state currently unused */
-
-  progress_subrange_end(&prog, &subprog);
-
-  progress_subrange_start(0.1, 1.0, &prog, &subprog);
-
-  /* partial success. */
-  r = process_path(plist, param, &subprog);
-  if (r) {
-    st->status = POTRACE_STATUS_INCOMPLETE;
-  }
-
-  progress_subrange_end(&prog, &subprog);
-
-  return st;
-}
-
-/* free a Potrace state, without disturbing errno. */
-void potrace_state_free(potrace_state_t *st) {
-  pathlist_free(st->plist);
-  free(st);
-}
-
-/* free a parameter list, without disturbing errno. */
-void potrace_param_free(potrace_param_t *p) {
-  free(p);
-}
-
-char *potrace_version(void) {
-    static char *ver = g_strdup_printf("potracelib %s", Inkscape::version_string);
-    return ver;
-}
-
-/*
-  Local Variables:
-  mode:c++
-  c-file-style:"stroustrup"
-  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
-  indent-tabs-mode:nil
-  fill-column:99
-  End:
-*/
-// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
 
=== removed file 'src/trace/potrace/potracelib.h'
--- src/trace/potrace/potracelib.h	2015-03-31 10:33:40 +0000
+++ src/trace/potrace/potracelib.h	1970-01-01 00:00:00 +0000
@@ -1,139 +0,0 @@
-/* Copyright (C) 2001-2015 Peter Selinger.
-   This file is part of Potrace. It is free software and it is covered
-   by the GNU General Public License. See the file COPYING for details. */
-
-#ifndef POTRACELIB_H
-#define POTRACELIB_H
-
-/* this file defines the API for the core Potrace library. For a more
-   detailed description of the API, see potracelib.pdf */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* ---------------------------------------------------------------------- */
-/* tracing parameters */
-
-/* turn policies */
-#define POTRACE_TURNPOLICY_BLACK 0
-#define POTRACE_TURNPOLICY_WHITE 1
-#define POTRACE_TURNPOLICY_LEFT 2
-#define POTRACE_TURNPOLICY_RIGHT 3
-#define POTRACE_TURNPOLICY_MINORITY 4
-#define POTRACE_TURNPOLICY_MAJORITY 5
-#define POTRACE_TURNPOLICY_RANDOM 6
-
-/* structure to hold progress bar callback data */
-struct potrace_progress_s {
-  void (*callback)(double progress, void *privdata); /* callback fn */
-  void *data;          /* callback function's private data */
-  double min, max;     /* desired range of progress, e.g. 0.0 to 1.0 */
-  double epsilon;      /* granularity: can skip smaller increments */
-};
-typedef struct potrace_progress_s potrace_progress_t;
-
-/* structure to hold tracing parameters */
-struct potrace_param_s {
-  int turdsize;        /* area of largest path to be ignored */
-  int turnpolicy;      /* resolves ambiguous turns in path decomposition */
-  double alphamax;     /* corner threshold */
-  int opticurve;       /* use curve optimization? */
-  double opttolerance; /* curve optimization tolerance */
-  potrace_progress_t progress; /* progress callback function */
-};
-typedef struct potrace_param_s potrace_param_t;
-
-/* ---------------------------------------------------------------------- */
-/* bitmaps */
-
-/* native word size */
-typedef unsigned long potrace_word;
-
-/* Internal bitmap format. The n-th scanline starts at scanline(n) =
-   (map + n*dy). Raster data is stored as a sequence of potrace_words
-   (NOT bytes). The leftmost bit of scanline n is the most significant
-   bit of scanline(n)[0]. */
-struct potrace_bitmap_s {
-  int w, h;              /* width and height, in pixels */
-  int dy;                /* words per scanline (not bytes) */
-  potrace_word *map;     /* raw data, dy*h words */
-};
-typedef struct potrace_bitmap_s potrace_bitmap_t;
-
-/* ---------------------------------------------------------------------- */
-/* curves */
-
-/* point */
-struct potrace_dpoint_s {
-  double x, y;
-};
-typedef struct potrace_dpoint_s potrace_dpoint_t;
-
-/* segment tags */
-#define POTRACE_CURVETO 1
-#define POTRACE_CORNER 2
-
-/* closed curve segment */
-struct potrace_curve_s {
-  int n;                    /* number of segments */
-  int *tag;                 /* tag[n]: POTRACE_CURVETO or POTRACE_CORNER */
-  potrace_dpoint_t (*c)[3]; /* c[n][3]: control points. 
-			       c[n][0] is unused for tag[n]=POTRACE_CORNER */
-};
-typedef struct potrace_curve_s potrace_curve_t;
-
-/* Linked list of signed curve segments. Also carries a tree structure. */
-struct potrace_path_s {
-  int area;                         /* area of the bitmap path */
-  int sign;                         /* '+' or '-', depending on orientation */
-  potrace_curve_t curve;            /* this path's vector data */
-
-  struct potrace_path_s *next;      /* linked list structure */
-
-  struct potrace_path_s *childlist; /* tree structure */
-  struct potrace_path_s *sibling;   /* tree structure */
-
-  struct potrace_privpath_s *priv;  /* private state */
-};
-typedef struct potrace_path_s potrace_path_t;  
-
-/* ---------------------------------------------------------------------- */
-/* Potrace state */
-
-#define POTRACE_STATUS_OK         0
-#define POTRACE_STATUS_INCOMPLETE 1
-
-struct potrace_state_s {
-  int status;                       
-  potrace_path_t *plist;            /* vector data */
-
-  struct potrace_privstate_s *priv; /* private state */
-};
-typedef struct potrace_state_s potrace_state_t;
-
-/* ---------------------------------------------------------------------- */
-/* API functions */
-
-/* get default parameters */
-potrace_param_t *potrace_param_default(void);
-
-/* free parameter set */
-void potrace_param_free(potrace_param_t *p);
-
-/* trace a bitmap*/
-potrace_state_t *potrace_trace(const potrace_param_t *param, 
-			       const potrace_bitmap_t *bm);
-
-/* free a Potrace state */
-void potrace_state_free(potrace_state_t *st);
-
-/* return a static plain text version string identifying this version
-   of potracelib */
-char *potrace_version(void);
-
-#ifdef  __cplusplus
-} /* end of extern "C" */
-#endif
-
-#endif /* POTRACELIB_H */
 
=== removed file 'src/trace/potrace/progress.h'
--- src/trace/potrace/progress.h	2015-03-31 10:33:40 +0000
+++ src/trace/potrace/progress.h	1970-01-01 00:00:00 +0000
@@ -1,77 +0,0 @@
-/* Copyright (C) 2001-2015 Peter Selinger.
-   This file is part of Potrace. It is free software and it is covered
-   by the GNU General Public License. See the file COPYING for details. */
-
-/* operations on potrace_progress_t objects, which are defined in
-   potracelib.h. Note: the code attempts to minimize runtime overhead
-   when no progress monitoring was requested. It also tries to
-   minimize excessive progress calculations beneath the "epsilon"
-   threshold. */
-
-#ifndef PROGRESS_H
-#define PROGRESS_H
-
-/* structure to hold progress bar callback data */
-struct progress_s {
-  void (*callback)(double progress, void *privdata); /* callback fn */
-  void *data;          /* callback function's private data */
-  double min, max;     /* desired range of progress, e.g. 0.0 to 1.0 */
-  double epsilon;      /* granularity: can skip smaller increments */
-  double b;            /* upper limit of subrange in superrange units */
-  double d_prev;       /* previous value of d */
-};
-typedef struct progress_s progress_t;
-
-/* notify given progress object of current progress. Note that d is
-   given in the 0.0-1.0 range, which will be scaled and translated to
-   the progress object's range. */
-static inline void progress_update(double d, progress_t *prog) {
-  if (prog != NULL && prog->callback != NULL) {
-    double d_scaled = prog->min * (1-d) + prog->max * d;
-    if (d == 1.0 || d_scaled >= prog->d_prev + prog->epsilon) {
-      prog->callback(prog->min * (1-d) + prog->max * d, prog->data);
-      prog->d_prev = d_scaled;
-    }
-  }
-}
-
-/* start a subrange of the given progress object. The range is
-   narrowed to [a..b], relative to 0.0-1.0 coordinates. If new range
-   is below granularity threshold, disable further subdivisions. */
-static inline void progress_subrange_start(double a, double b, const progress_t *prog, progress_t *sub) {
-  double min, max;
-
-  if (prog == NULL || prog->callback == NULL) {
-    sub->callback = NULL;
-    return;
-  }
-
-  min = prog->min * (1-a) + prog->max * a;
-  max = prog->min * (1-b) + prog->max * b;
-
-  if (max - min < prog->epsilon) {
-    sub->callback = NULL;    /* no further progress info in subrange */
-    sub->b = b;
-    return;
-  }
-  sub->callback = prog->callback;
-  sub->data = prog->data;
-  sub->epsilon = prog->epsilon;
-  sub->min = min;
-  sub->max = max;
-  sub->d_prev = prog->d_prev;
-  return;
-}
-
-static inline void progress_subrange_end(progress_t *prog, progress_t *sub) {
-  if (prog != NULL && prog->callback != NULL) {
-    if (sub->callback == NULL) {
-      progress_update(sub->b, prog);
-    } else {
-      prog->d_prev = sub->d_prev;
-    }
-  }    
-}
-
-#endif /* PROGRESS_H */
-
 
=== removed file 'src/trace/potrace/render.cpp'
--- src/trace/potrace/render.cpp	2015-03-31 10:33:40 +0000
+++ src/trace/potrace/render.cpp	1970-01-01 00:00:00 +0000
@@ -1,243 +0,0 @@
-/* Copyright (C) 2001-2015 Peter Selinger.
-   This file is part of Potrace. It is free software and it is covered
-   by the GNU General Public License. See the file COPYING for details. */
-
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <math.h>
-#include <string.h>
-
-#include "render.h"
-#include "greymap.h"
-#include "auxiliary.h"
-
-/* ---------------------------------------------------------------------- */
-/* routines for anti-aliased rendering of curves */
-
-/* we use the following method. Given a point (x,y) (with real-valued
-   coordinates) in the plane, let (xi,yi) be the integer part of the
-   coordinates, i.e., xi=floor(x), yi=floor(y). Define a path from
-   (x,y) to infinity as follows: path(x,y) =
-   (x,y)--(xi+1,y)--(xi+1,yi)--(+infty,yi).  Now as the point (x,y)
-   moves smoothly across the plane, the path path(x,y) sweeps
-   (non-smoothly) across a certain area. We proportionately blacken
-   the area as the path moves "downward", and we whiten the area as
-   the path moves "upward". This way, after the point has traversed a
-   closed curve, the interior of the curve has been darkened
-   (counterclockwise movement) or lightened (clockwise movement). (The
-   "grey shift" is actually proportional to the winding number). By
-   choosing the above path with mostly integer coordinates, we achieve
-   that only pixels close to (x,y) receive grey values and are subject
-   to round-off errors. The grey value of pixels far away from (x,y)
-   is always in "integer" (where 0=black, 1=white).  As a special
-   trick, we keep an accumulator rm->a1, which holds a double value to
-   be added to the grey value to be added to the current pixel
-   (xi,yi).  Only when changing "current" pixels, we convert this
-   double value to an integer. This way we avoid round-off errors at
-   the meeting points of line segments. Another speedup measure is
-   that we sometimes use the rm->incrow_buf array to postpone
-   incrementing or decrementing an entire row. If incrow_buf[y]=x+1!=0,
-   then all the pixels (x,y),(x+1,y),(x+2,y),... are scheduled to be
-   incremented/decremented (which one is the case will be clear from 
-   context). This keeps the greymap operations reasonably local. */
-
-/* allocate a new rendering state */
-render_t *render_new(greymap_t *gm) {
-  render_t *rm;
-
-  rm = (render_t *) malloc(sizeof(render_t));
-  if (!rm) {
-    return NULL;
-  }
-  memset(rm, 0, sizeof(render_t));
-  rm->gm = gm;
-  rm->incrow_buf = (int *) calloc(gm->h, sizeof(int));
-  if (!rm->incrow_buf) {
-    free(rm);
-    return NULL;
-  }
-  memset(rm->incrow_buf, 0, gm->h * sizeof(int));
-  return rm;
-}
-
-/* free a given rendering state. Note: this does not free the
-   underlying greymap. */
-void render_free(render_t *rm) {
-  free(rm->incrow_buf);
-  free(rm);
-}
-
-/* close path */
-void render_close(render_t *rm) {
-  if (rm->x0 != rm->x1 || rm->y0 != rm->y1) {
-    render_lineto(rm, rm->x0, rm->y0);
-  }
-  GM_INC(rm->gm, rm->x0i, rm->y0i, (rm->a0+rm->a1)*255);
-
-  /* assert (rm->x0i != rm->x1i || rm->y0i != rm->y1i); */
-  
-  /* the persistent state is now undefined */
-}
-
-/* move point */
-void render_moveto(render_t *rm, double x, double y) {
-  /* close the previous path */
-  render_close(rm);
-
-  rm->x0 = rm->x1 = x;
-  rm->y0 = rm->y1 = y;
-  rm->x0i = (int)floor(rm->x0);
-  rm->x1i = (int)floor(rm->x1);
-  rm->y0i = (int)floor(rm->y0);
-  rm->y1i = (int)floor(rm->y1);
-  rm->a0 = rm->a1 = 0;
-}
-
-/* add b to pixels (x,y) and all pixels to the right of it. However,
-   use rm->incrow_buf as a buffer to economize on multiple calls */
-static void incrow(render_t *rm, int x, int y, int b) {
-  int i, x0;
-
-  if (y < 0 || y >= rm->gm->h) {
-    return;
-  }
-
-  if (x < 0) {
-    x = 0;
-  } else if (x > rm->gm->w) {
-    x = rm->gm->w;
-  }
-  if (rm->incrow_buf[y] == 0) {
-    rm->incrow_buf[y] = x+1; /* store x+1 so that we can use 0 for "vacant" */
-    return;
-  }
-  x0 = rm->incrow_buf[y]-1;
-  rm->incrow_buf[y] = 0;
-  if (x0 < x) {
-    for (i=x0; i<x; i++) {
-      GM_INC(rm->gm, i, y, -b);
-    }
-  } else {
-    for (i=x; i<x0; i++) {
-      GM_INC(rm->gm, i, y, b);
-    }
-  }    
-}
-
-/* render a straight line */
-void render_lineto(render_t *rm, double x2, double y2) {
-  int x2i, y2i;
-  double t0=2, s0=2;
-  int sn, tn;
-  double ss=2, ts=2;
-  double r0, r1;
-  int i, j;
-  int rxi, ryi;
-  int s;
-
-  x2i = (int)floor(x2);
-  y2i = (int)floor(y2);
-
-  sn = abs(x2i - rm->x1i);
-  tn = abs(y2i - rm->y1i);
-
-  if (sn) {
-    s0 = ((x2>rm->x1 ? rm->x1i+1 : rm->x1i) - rm->x1)/(x2-rm->x1);
-    ss = fabs(1.0/(x2-rm->x1));
-  }
-  if (tn) {
-    t0 = ((y2>rm->y1 ? rm->y1i+1 : rm->y1i) - rm->y1)/(y2-rm->y1);
-    ts = fabs(1.0/(y2-rm->y1));
-  }
-
-  r0 = 0;
-
-  i = 0;
-  j = 0;
-
-  rxi = rm->x1i;
-  ryi = rm->y1i;
-
-  while (i<sn || j<tn) {
-    if (j>=tn || (i<sn && s0+i*ss < t0+j*ts)) {
-      r1 = s0+i*ss;
-      i++;
-      s = 1;
-    } else {
-      r1 = t0+j*ts;
-      j++;
-      s = 0;
-    }
-    /* render line from r0 to r1 segment of (rm->x1,rm->y1)..(x2,y2) */
-    
-    /* move point to r1 */
-    rm->a1 += (r1-r0)*(y2-rm->y1)*(rxi+1-((r0+r1)/2.0*(x2-rm->x1)+rm->x1));
-
-    /* move point across pixel boundary */
-    if (s && x2>rm->x1) {
-      GM_INC(rm->gm, rxi, ryi, rm->a1*255);
-      rm->a1 = 0;
-      rxi++;
-      rm->a1 += rm->y1+r1*(y2-rm->y1)-ryi;
-    } else if (!s && y2>rm->y1) {
-      GM_INC(rm->gm, rxi, ryi, rm->a1*255);
-      rm->a1 = 0;
-      incrow(rm, rxi+1, ryi, 255);
-      ryi++;
-    } else if (s && x2<=rm->x1) {
-      rm->a1 -= rm->y1+r1*(y2-rm->y1)-ryi;
-      GM_INC(rm->gm, rxi, ryi, rm->a1*255);
-      rm->a1 = 0;
-      rxi--;
-    } else if (!s && y2<=rm->y1) {
-      GM_INC(rm->gm, rxi, ryi, rm->a1*255);
-      rm->a1 = 0;
-      ryi--;
-      incrow(rm, rxi+1, ryi, -255);
-    }
-
-    r0 = r1;
-  }
-  
-  /* move point to (x2,y2) */
-  
-  r1 = 1;
-  rm->a1 += (r1-r0)*(y2-rm->y1)*(rxi+1-((r0+r1)/2.0*(x2-rm->x1)+rm->x1));
-
-  rm->x1i = x2i;
-  rm->y1i = y2i;
-  rm->x1 = x2;
-  rm->y1 = y2;
-
-  /* assert (rxi != rm->x1i || ryi != rm->y1i); */
-}
-
-/* render a Bezier curve. */
-void render_curveto(render_t *rm, double x2, double y2, double x3, double y3, double x4, double y4) {
-  double x1, y1, dd0, dd1, dd, delta, e2, epsilon, t;
-
-  x1 = rm->x1;  /* starting point */
-  y1 = rm->y1;
-
-  /* we approximate the curve by small line segments. The interval
-     size, epsilon, is determined on the fly so that the distance
-     between the true curve and its approximation does not exceed the
-     desired accuracy delta. */
-
-  delta = .1;  /* desired accuracy, in pixels */
-
-  /* let dd = maximal value of 2nd derivative over curve - this must
-     occur at an endpoint. */
-  dd0 = sq(x1-2*x2+x3) + sq(y1-2*y2+y3);
-  dd1 = sq(x2-2*x3+x4) + sq(y2-2*y3+y4);
-  dd = 6*sqrt(max(dd0, dd1));
-  e2 = 8*delta <= dd ? 8*delta/dd : 1;
-  epsilon = sqrt(e2);  /* necessary interval size */
-
-  for (t=epsilon; t<1; t+=epsilon) {
-    render_lineto(rm, x1*cu(1-t)+3*x2*sq(1-t)*t+3*x3*(1-t)*sq(t)+x4*cu(t),
-		  y1*cu(1-t)+3*y2*sq(1-t)*t+3*y3*(1-t)*sq(t)+y4*cu(t));
-  }
-  render_lineto(rm, x4, y4);
-}
 
=== removed file 'src/trace/potrace/render.h'
--- src/trace/potrace/render.h	2015-03-31 10:33:40 +0000
+++ src/trace/potrace/render.h	1970-01-01 00:00:00 +0000
@@ -1,27 +0,0 @@
-/* Copyright (C) 2001-2015 Peter Selinger.
-   This file is part of Potrace. It is free software and it is covered
-   by the GNU General Public License. See the file COPYING for details. */
-
-
-#ifndef RENDER_H
-#define RENDER_H
-
-#include "greymap.h"
-
-struct render_s {
-  greymap_t *gm;
-  double x0, y0, x1, y1;
-  int x0i, y0i, x1i, y1i;
-  double a0, a1;
-  int *incrow_buf;
-};
-typedef struct render_s render_t;
-
-render_t *render_new(greymap_t *gm);
-void render_free(render_t *rm);
-void render_close(render_t *rm);
-void render_moveto(render_t *rm, double x, double y);
-void render_lineto(render_t *rm, double x, double y);
-void render_curveto(render_t *rm, double x2, double y2, double x3, double y3, double x4, double y4);
-
-#endif /* RENDER_H */
 
=== removed file 'src/trace/potrace/trace.cpp'
--- src/trace/potrace/trace.cpp	2015-03-31 10:33:40 +0000
+++ src/trace/potrace/trace.cpp	1970-01-01 00:00:00 +0000
@@ -1,1245 +0,0 @@
-/* Copyright (C) 2001-2015 Peter Selinger.
-   This file is part of Potrace. It is free software and it is covered
-   by the GNU General Public License. See the file COPYING for details. */
-
-/* transform jaggy paths into smooth curves */
-
-#include <stdio.h>
-#include <math.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "potracelib.h"
-#include "curve.h"
-#include "lists.h"
-#include "auxiliary.h"
-#include "trace.h"
-#include "progress.h"
-
-#define INFTY 10000000	/* it suffices that this is longer than any
-			   path; it need not be really infinite */
-#define COS179 -0.999847695156	 /* the cosine of 179 degrees */
-
-/* ---------------------------------------------------------------------- */
-#define SAFE_CALLOC(var, n, typ) \
-  if ((var = (typ *)calloc(n, sizeof(typ))) == NULL) goto calloc_error 
-
-/* ---------------------------------------------------------------------- */
-/* auxiliary functions */
-
-/* return a direction that is 90 degrees counterclockwise from p2-p0,
-   but then restricted to one of the major wind directions (n, nw, w, etc) */
-static inline point_t dorth_infty(dpoint_t p0, dpoint_t p2) {
-  point_t r;
-  
-  r.y = sign(p2.x-p0.x);
-  r.x = -sign(p2.y-p0.y);
-
-  return r;
-}
-
-/* return (p1-p0)x(p2-p0), the area of the parallelogram */
-static inline double dpara(dpoint_t p0, dpoint_t p1, dpoint_t p2) {
-  double x1, y1, x2, y2;
-
-  x1 = p1.x-p0.x;
-  y1 = p1.y-p0.y;
-  x2 = p2.x-p0.x;
-  y2 = p2.y-p0.y;
-
-  return x1*y2 - x2*y1;
-}
-
-/* ddenom/dpara have the property that the square of radius 1 centered
-   at p1 intersects the line p0p2 iff |dpara(p0,p1,p2)| <= ddenom(p0,p2) */
-static inline double ddenom(dpoint_t p0, dpoint_t p2) {
-  point_t r = dorth_infty(p0, p2);
-
-  return r.y*(p2.x-p0.x) - r.x*(p2.y-p0.y);
-}
-
-/* return 1 if a <= b < c < a, in a cyclic sense (mod n) */
-static inline int cyclic(int a, int b, int c) {
-  if (a<=c) {
-    return (a<=b && b<c);
-  } else {
-    return (a<=b || b<c);
-  }
-}
-
-/* determine the center and slope of the line i..j. Assume i<j. Needs
-   "sum" components of p to be set. */
-static void pointslope(privpath_t *pp, int i, int j, dpoint_t *ctr, dpoint_t *dir) {
-  /* assume i<j */
-
-  int n = pp->len;
-  sums_t *sums = pp->sums;
-
-  double x, y, x2, xy, y2;
-  double k;
-  double a, b, c, lambda2, l;
-  int r=0; /* rotations from i to j */
-
-  while (j>=n) {
-    j-=n;
-    r+=1;
-  }
-  while (i>=n) {
-    i-=n;
-    r-=1;
-  }
-  while (j<0) {
-    j+=n;
-    r-=1;
-  }
-  while (i<0) {
-    i+=n;
-    r+=1;
-  }
-  
-  x = sums[j+1].x-sums[i].x+r*sums[n].x;
-  y = sums[j+1].y-sums[i].y+r*sums[n].y;
-  x2 = sums[j+1].x2-sums[i].x2+r*sums[n].x2;
-  xy = sums[j+1].xy-sums[i].xy+r*sums[n].xy;
-  y2 = sums[j+1].y2-sums[i].y2+r*sums[n].y2;
-  k = j+1-i+r*n;
-  
-  ctr->x = x/k;
-  ctr->y = y/k;
-
-  a = (x2-(double)x*x/k)/k;
-  b = (xy-(double)x*y/k)/k;
-  c = (y2-(double)y*y/k)/k;
-  
-  lambda2 = (a+c+sqrt((a-c)*(a-c)+4*b*b))/2; /* larger e.value */
-
-  /* now find e.vector for lambda2 */
-  a -= lambda2;
-  c -= lambda2;
-
-  if (fabs(a) >= fabs(c)) {
-    l = sqrt(a*a+b*b);
-    if (l!=0) {
-      dir->x = -b/l;
-      dir->y = a/l;
-    }
-  } else {
-    l = sqrt(c*c+b*b);
-    if (l!=0) {
-      dir->x = -c/l;
-      dir->y = b/l;
-    }
-  }
-  if (l==0) {
-    dir->x = dir->y = 0;   /* sometimes this can happen when k=4:
-			      the two eigenvalues coincide */
-  }
-}
-
-/* the type of (affine) quadratic forms, represented as symmetric 3x3
-   matrices.  The value of the quadratic form at a vector (x,y) is v^t
-   Q v, where v = (x,y,1)^t. */
-typedef double quadform_t[3][3];
-
-/* Apply quadratic form Q to vector w = (w.x,w.y) */
-static inline double quadform(quadform_t Q, dpoint_t w) {
-  double v[3];
-  int i, j;
-  double sum;
-
-  v[0] = w.x;
-  v[1] = w.y;
-  v[2] = 1;
-  sum = 0.0;
-
-  for (i=0; i<3; i++) {
-    for (j=0; j<3; j++) {
-      sum += v[i] * Q[i][j] * v[j];
-    }
-  }
-  return sum;
-}
-
-/* calculate p1 x p2 */
-static inline int xprod(point_t p1, point_t p2) {
-  return p1.x*p2.y - p1.y*p2.x;
-}
-
-/* calculate (p1-p0)x(p3-p2) */
-static inline double cprod(dpoint_t p0, dpoint_t p1, dpoint_t p2, dpoint_t p3) {
-  double x1, y1, x2, y2;
-
-  x1 = p1.x - p0.x;
-  y1 = p1.y - p0.y;
-  x2 = p3.x - p2.x;
-  y2 = p3.y - p2.y;
-
-  return x1*y2 - x2*y1;
-}
-
-/* calculate (p1-p0)*(p2-p0) */
-static inline double iprod(dpoint_t p0, dpoint_t p1, dpoint_t p2) {
-  double x1, y1, x2, y2;
-
-  x1 = p1.x - p0.x;
-  y1 = p1.y - p0.y;
-  x2 = p2.x - p0.x;
-  y2 = p2.y - p0.y;
-
-  return x1*x2 + y1*y2;
-}
-
-/* calculate (p1-p0)*(p3-p2) */
-static inline double iprod1(dpoint_t p0, dpoint_t p1, dpoint_t p2, dpoint_t p3) {
-  double x1, y1, x2, y2;
-
-  x1 = p1.x - p0.x;
-  y1 = p1.y - p0.y;
-  x2 = p3.x - p2.x;
-  y2 = p3.y - p2.y;
-
-  return x1*x2 + y1*y2;
-}
-
-/* calculate distance between two points */
-static inline double ddist(dpoint_t p, dpoint_t q) {
-  return sqrt(sq(p.x-q.x)+sq(p.y-q.y));
-}
-
-/* calculate point of a bezier curve */
-static inline dpoint_t bezier(double t, dpoint_t p0, dpoint_t p1, dpoint_t p2, dpoint_t p3) {
-  double s = 1-t;
-  dpoint_t res;
-
-  /* Note: a good optimizing compiler (such as gcc-3) reduces the
-     following to 16 multiplications, using common subexpression
-     elimination. */
-
-  res.x = s*s*s*p0.x + 3*(s*s*t)*p1.x + 3*(t*t*s)*p2.x + t*t*t*p3.x;
-  res.y = s*s*s*p0.y + 3*(s*s*t)*p1.y + 3*(t*t*s)*p2.y + t*t*t*p3.y;
-
-  return res;
-}
-
-/* calculate the point t in [0..1] on the (convex) bezier curve
-   (p0,p1,p2,p3) which is tangent to q1-q0. Return -1.0 if there is no
-   solution in [0..1]. */
-static double tangent(dpoint_t p0, dpoint_t p1, dpoint_t p2, dpoint_t p3, dpoint_t q0, dpoint_t q1) {
-  double A, B, C;   /* (1-t)^2 A + 2(1-t)t B + t^2 C = 0 */
-  double a, b, c;   /* a t^2 + b t + c = 0 */
-  double d, s, r1, r2;
-
-  A = cprod(p0, p1, q0, q1);
-  B = cprod(p1, p2, q0, q1);
-  C = cprod(p2, p3, q0, q1);
-
-  a = A - 2*B + C;
-  b = -2*A + 2*B;
-  c = A;
-  
-  d = b*b - 4*a*c;
-
-  if (a==0 || d<0) {
-    return -1.0;
-  }
-
-  s = sqrt(d);
-
-  r1 = (-b + s) / (2 * a);
-  r2 = (-b - s) / (2 * a);
-
-  if (r1 >= 0 && r1 <= 1) {
-    return r1;
-  } else if (r2 >= 0 && r2 <= 1) {
-    return r2;
-  } else {
-    return -1.0;
-  }
-}
-
-/* ---------------------------------------------------------------------- */
-/* Preparation: fill in the sum* fields of a path (used for later
-   rapid summing). Return 0 on success, 1 with errno set on
-   failure. */
-static int calc_sums(privpath_t *pp) {
-  int i, x, y;
-  int n = pp->len;
-
-  SAFE_CALLOC(pp->sums, pp->len+1, sums_t);
-
-  /* origin */
-  pp->x0 = pp->pt[0].x;
-  pp->y0 = pp->pt[0].y;
-
-  /* preparatory computation for later fast summing */
-  pp->sums[0].x2 = pp->sums[0].xy = pp->sums[0].y2 = pp->sums[0].x = pp->sums[0].y = 0;
-  for (i=0; i<n; i++) {
-    x = pp->pt[i].x - pp->x0;
-    y = pp->pt[i].y - pp->y0;
-    pp->sums[i+1].x = pp->sums[i].x + x;
-    pp->sums[i+1].y = pp->sums[i].y + y;
-    pp->sums[i+1].x2 = pp->sums[i].x2 + x*x;
-    pp->sums[i+1].xy = pp->sums[i].xy + x*y;
-    pp->sums[i+1].y2 = pp->sums[i].y2 + y*y;
-  }
-  return 0;  
-
- calloc_error:
-  return 1;
-}
-
-/* ---------------------------------------------------------------------- */
-/* Stage 1: determine the straight subpaths (Sec. 2.2.1). Fill in the
-   "lon" component of a path object (based on pt/len).	For each i,
-   lon[i] is the furthest index such that a straight line can be drawn
-   from i to lon[i]. Return 1 on error with errno set, else 0. */
-
-/* this algorithm depends on the fact that the existence of straight
-   subpaths is a triplewise property. I.e., there exists a straight
-   line through squares i0,...,in iff there exists a straight line
-   through i,j,k, for all i0<=i<j<k<=in. (Proof?) */
-
-/* this implementation of calc_lon is O(n^2). It replaces an older
-   O(n^3) version. A "constraint" means that future points must
-   satisfy xprod(constraint[0], cur) >= 0 and xprod(constraint[1],
-   cur) <= 0. */
-
-/* Remark for Potrace 1.1: the current implementation of calc_lon is
-   more complex than the implementation found in Potrace 1.0, but it
-   is considerably faster. The introduction of the "nc" data structure
-   means that we only have to test the constraints for "corner"
-   points. On a typical input file, this speeds up the calc_lon
-   function by a factor of 31.2, thereby decreasing its time share
-   within the overall Potrace algorithm from 72.6% to 7.82%, and
-   speeding up the overall algorithm by a factor of 3.36. On another
-   input file, calc_lon was sped up by a factor of 6.7, decreasing its
-   time share from 51.4% to 13.61%, and speeding up the overall
-   algorithm by a factor of 1.78. In any case, the savings are
-   substantial. */
-
-/* returns 0 on success, 1 on error with errno set */
-static int calc_lon(privpath_t *pp) {
-  point_t *pt = pp->pt;
-  int n = pp->len;
-  int i, j, k, k1;
-  int ct[4], dir;
-  point_t constraint[2];
-  point_t cur;
-  point_t off;
-  int *pivk = NULL;  /* pivk[n] */
-  int *nc = NULL;    /* nc[n]: next corner */
-  point_t dk;  /* direction of k-k1 */
-  int a, b, c, d;
-
-  SAFE_CALLOC(pivk, n, int);
-  SAFE_CALLOC(nc, n, int);
-
-  /* initialize the nc data structure. Point from each point to the
-     furthest future point to which it is connected by a vertical or
-     horizontal segment. We take advantage of the fact that there is
-     always a direction change at 0 (due to the path decomposition
-     algorithm). But even if this were not so, there is no harm, as
-     in practice, correctness does not depend on the word "furthest"
-     above.  */
-  k = 0;
-  for (i=n-1; i>=0; i--) {
-    if (pt[i].x != pt[k].x && pt[i].y != pt[k].y) {
-      k = i+1;  /* necessarily i<n-1 in this case */
-    }
-    nc[i] = k;
-  }
-
-  SAFE_CALLOC(pp->lon, n, int);
-
-  /* determine pivot points: for each i, let pivk[i] be the furthest k
-     such that all j with i<j<k lie on a line connecting i,k. */
-  
-  for (i=n-1; i>=0; i--) {
-    ct[0] = ct[1] = ct[2] = ct[3] = 0;
-
-    /* keep track of "directions" that have occurred */
-    dir = (3+3*(pt[mod(i+1,n)].x-pt[i].x)+(pt[mod(i+1,n)].y-pt[i].y))/2;
-    ct[dir]++;
-
-    constraint[0].x = 0;
-    constraint[0].y = 0;
-    constraint[1].x = 0;
-    constraint[1].y = 0;
-
-    /* find the next k such that no straight line from i to k */
-    k = nc[i];
-    k1 = i;
-    while (1) {
-      
-      dir = (3+3*sign(pt[k].x-pt[k1].x)+sign(pt[k].y-pt[k1].y))/2;
-      ct[dir]++;
-
-      /* if all four "directions" have occurred, cut this path */
-      if (ct[0] && ct[1] && ct[2] && ct[3]) {
-	pivk[i] = k1;
-	goto foundk;
-      }
-
-      cur.x = pt[k].x - pt[i].x;
-      cur.y = pt[k].y - pt[i].y;
-
-      /* see if current constraint is violated */
-      if (xprod(constraint[0], cur) < 0 || xprod(constraint[1], cur) > 0) {
-	goto constraint_viol;
-      }
-
-      /* else, update constraint */
-      if (abs(cur.x) <= 1 && abs(cur.y) <= 1) {
-	/* no constraint */
-      } else {
-	off.x = cur.x + ((cur.y>=0 && (cur.y>0 || cur.x<0)) ? 1 : -1);
-	off.y = cur.y + ((cur.x<=0 && (cur.x<0 || cur.y<0)) ? 1 : -1);
-	if (xprod(constraint[0], off) >= 0) {
-	  constraint[0] = off;
-	}
-	off.x = cur.x + ((cur.y<=0 && (cur.y<0 || cur.x<0)) ? 1 : -1);
-	off.y = cur.y + ((cur.x>=0 && (cur.x>0 || cur.y<0)) ? 1 : -1);
-	if (xprod(constraint[1], off) <= 0) {
-	  constraint[1] = off;
-	}
-      }	
-      k1 = k;
-      k = nc[k1];
-      if (!cyclic(k,i,k1)) {
-	break;
-      }
-    }
-  constraint_viol:
-    /* k1 was the last "corner" satisfying the current constraint, and
-       k is the first one violating it. We now need to find the last
-       point along k1..k which satisfied the constraint. */
-    dk.x = sign(pt[k].x-pt[k1].x);
-    dk.y = sign(pt[k].y-pt[k1].y);
-    cur.x = pt[k1].x - pt[i].x;
-    cur.y = pt[k1].y - pt[i].y;
-    /* find largest integer j such that xprod(constraint[0], cur+j*dk)
-       >= 0 and xprod(constraint[1], cur+j*dk) <= 0. Use bilinearity
-       of xprod. */
-    a = xprod(constraint[0], cur);
-    b = xprod(constraint[0], dk);
-    c = xprod(constraint[1], cur);
-    d = xprod(constraint[1], dk);
-    /* find largest integer j such that a+j*b>=0 and c+j*d<=0. This
-       can be solved with integer arithmetic. */
-    j = INFTY;
-    if (b<0) {
-      j = floordiv(a,-b);
-    }
-    if (d>0) {
-      j = min(j, floordiv(-c,d));
-    }
-    pivk[i] = mod(k1+j,n);
-  foundk:
-    ;
-  } /* for i */
-
-  /* clean up: for each i, let lon[i] be the largest k such that for
-     all i' with i<=i'<k, i'<k<=pivk[i']. */
-
-  j=pivk[n-1];
-  pp->lon[n-1]=j;
-  for (i=n-2; i>=0; i--) {
-    if (cyclic(i+1,pivk[i],j)) {
-      j=pivk[i];
-    }
-    pp->lon[i]=j;
-  }
-
-  for (i=n-1; cyclic(mod(i+1,n),j,pp->lon[i]); i--) {
-    pp->lon[i] = j;
-  }
-
-  free(pivk);
-  free(nc);
-  return 0;
-
- calloc_error:
-  free(pivk);
-  free(nc);
-  return 1;
-}
-
-
-/* ---------------------------------------------------------------------- */
-/* Stage 2: calculate the optimal polygon (Sec. 2.2.2-2.2.4). */ 
-
-/* Auxiliary function: calculate the penalty of an edge from i to j in
-   the given path. This needs the "lon" and "sum*" data. */
-
-static double penalty3(privpath_t *pp, int i, int j) {
-  int n = pp->len;
-  point_t *pt = pp->pt;
-  sums_t *sums = pp->sums;
-
-  /* assume 0<=i<j<=n  */
-  double x, y, x2, xy, y2;
-  double k;
-  double a, b, c, s;
-  double px, py, ex, ey;
-
-  int r = 0; /* rotations from i to j */
-
-  if (j>=n) {
-    j -= n;
-    r = 1;
-  }
-  
-  /* critical inner loop: the "if" gives a 4.6 percent speedup */
-  if (r == 0) {
-    x = sums[j+1].x - sums[i].x;
-    y = sums[j+1].y - sums[i].y;
-    x2 = sums[j+1].x2 - sums[i].x2;
-    xy = sums[j+1].xy - sums[i].xy;
-    y2 = sums[j+1].y2 - sums[i].y2;
-    k = j+1 - i;
-  } else {
-    x = sums[j+1].x - sums[i].x + sums[n].x;
-    y = sums[j+1].y - sums[i].y + sums[n].y;
-    x2 = sums[j+1].x2 - sums[i].x2 + sums[n].x2;
-    xy = sums[j+1].xy - sums[i].xy + sums[n].xy;
-    y2 = sums[j+1].y2 - sums[i].y2 + sums[n].y2;
-    k = j+1 - i + n;
-  } 
-
-  px = (pt[i].x + pt[j].x) / 2.0 - pt[0].x;
-  py = (pt[i].y + pt[j].y) / 2.0 - pt[0].y;
-  ey = (pt[j].x - pt[i].x);
-  ex = -(pt[j].y - pt[i].y);
-
-  a = ((x2 - 2*x*px) / k + px*px);
-  b = ((xy - x*py - y*px) / k + px*py);
-  c = ((y2 - 2*y*py) / k + py*py);
-  
-  s = ex*ex*a + 2*ex*ey*b + ey*ey*c;
-
-  return sqrt(s);
-}
-
-/* find the optimal polygon. Fill in the m and po components. Return 1
-   on failure with errno set, else 0. Non-cyclic version: assumes i=0
-   is in the polygon. Fixme: implement cyclic version. */
-static int bestpolygon(privpath_t *pp)
-{
-  int i, j, m, k;     
-  int n = pp->len;
-  double *pen = NULL; /* pen[n+1]: penalty vector */
-  int *prev = NULL;   /* prev[n+1]: best path pointer vector */
-  int *clip0 = NULL;  /* clip0[n]: longest segment pointer, non-cyclic */
-  int *clip1 = NULL;  /* clip1[n+1]: backwards segment pointer, non-cyclic */
-  int *seg0 = NULL;    /* seg0[m+1]: forward segment bounds, m<=n */
-  int *seg1 = NULL;   /* seg1[m+1]: backward segment bounds, m<=n */
-  double thispen;
-  double best;
-  int c;
-
-  SAFE_CALLOC(pen, n+1, double);
-  SAFE_CALLOC(prev, n+1, int);
-  SAFE_CALLOC(clip0, n, int);
-  SAFE_CALLOC(clip1, n+1, int);
-  SAFE_CALLOC(seg0, n+1, int);
-  SAFE_CALLOC(seg1, n+1, int);
-
-  /* calculate clipped paths */
-  for (i=0; i<n; i++) {
-    c = mod(pp->lon[mod(i-1,n)]-1,n);
-    if (c == i) {
-      c = mod(i+1,n);
-    }
-    if (c < i) {
-      clip0[i] = n;
-    } else {
-      clip0[i] = c;
-    }
-  }
-
-  /* calculate backwards path clipping, non-cyclic. j <= clip0[i] iff
-     clip1[j] <= i, for i,j=0..n. */
-  j = 1;
-  for (i=0; i<n; i++) {
-    while (j <= clip0[i]) {
-      clip1[j] = i;
-      j++;
-    }
-  }
-
-  /* calculate seg0[j] = longest path from 0 with j segments */
-  i = 0;
-  for (j=0; i<n; j++) {
-    seg0[j] = i;
-    i = clip0[i];
-  }
-  seg0[j] = n;
-  m = j;
-
-  /* calculate seg1[j] = longest path to n with m-j segments */
-  i = n;
-  for (j=m; j>0; j--) {
-    seg1[j] = i;
-    i = clip1[i];
-  }
-  seg1[0] = 0;
-
-  /* now find the shortest path with m segments, based on penalty3 */
-  /* note: the outer 2 loops jointly have at most n iterations, thus
-     the worst-case behavior here is quadratic. In practice, it is
-     close to linear since the inner loop tends to be short. */
-  pen[0]=0;
-  for (j=1; j<=m; j++) {
-    for (i=seg1[j]; i<=seg0[j]; i++) {
-      best = -1;
-      for (k=seg0[j-1]; k>=clip1[i]; k--) {
-	thispen = penalty3(pp, k, i) + pen[k];
-	if (best < 0 || thispen < best) {
-	  prev[i] = k;
-	  best = thispen;
-	}
-      }
-      pen[i] = best;
-    }
-  }
-
-  pp->m = m;
-  SAFE_CALLOC(pp->po, m, int);
-
-  /* read off shortest path */
-  for (i=n, j=m-1; i>0; j--) {
-    i = prev[i];
-    pp->po[j] = i;
-  }
-
-  free(pen);
-  free(prev);
-  free(clip0);
-  free(clip1);
-  free(seg0);
-  free(seg1);
-  return 0;
-  
- calloc_error:
-  free(pen);
-  free(prev);
-  free(clip0);
-  free(clip1);
-  free(seg0);
-  free(seg1);
-  return 1;
-}
-
-/* ---------------------------------------------------------------------- */
-/* Stage 3: vertex adjustment (Sec. 2.3.1). */
-
-/* Adjust vertices of optimal polygon: calculate the intersection of
-   the two "optimal" line segments, then move it into the unit square
-   if it lies outside. Return 1 with errno set on error; 0 on
-   success. */
-
-static int adjust_vertices(privpath_t *pp) {
-  int m = pp->m;
-  int *po = pp->po;
-  int n = pp->len;
-  point_t *pt = pp->pt;
-  int x0 = pp->x0;
-  int y0 = pp->y0;
-
-  dpoint_t *ctr = NULL;      /* ctr[m] */
-  dpoint_t *dir = NULL;      /* dir[m] */
-  quadform_t *q = NULL;      /* q[m] */
-  double v[3];
-  double d;
-  int i, j, k, l;
-  dpoint_t s;
-  int r;
-
-  SAFE_CALLOC(ctr, m, dpoint_t);
-  SAFE_CALLOC(dir, m, dpoint_t);
-  SAFE_CALLOC(q, m, quadform_t);
-
-  r = privcurve_init(&pp->curve, m);
-  if (r) {
-    goto calloc_error;
-  }
-  
-  /* calculate "optimal" point-slope representation for each line
-     segment */
-  for (i=0; i<m; i++) {
-    j = po[mod(i+1,m)];
-    j = mod(j-po[i],n)+po[i];
-    pointslope(pp, po[i], j, &ctr[i], &dir[i]);
-  }
-
-  /* represent each line segment as a singular quadratic form; the
-     distance of a point (x,y) from the line segment will be
-     (x,y,1)Q(x,y,1)^t, where Q=q[i]. */
-  for (i=0; i<m; i++) {
-    d = sq(dir[i].x) + sq(dir[i].y);
-    if (d == 0.0) {
-      for (j=0; j<3; j++) {
-	for (k=0; k<3; k++) {
-	  q[i][j][k] = 0;
-	}
-      }
-    } else {
-      v[0] = dir[i].y;
-      v[1] = -dir[i].x;
-      v[2] = - v[1] * ctr[i].y - v[0] * ctr[i].x;
-      for (l=0; l<3; l++) {
-	for (k=0; k<3; k++) {
-	  q[i][l][k] = v[l] * v[k] / d;
-	}
-      }
-    }
-  }
-
-  /* now calculate the "intersections" of consecutive segments.
-     Instead of using the actual intersection, we find the point
-     within a given unit square which minimizes the square distance to
-     the two lines. */
-  for (i=0; i<m; i++) {
-    quadform_t Q;
-    dpoint_t w;
-    double dx, dy;
-    double det;
-    double min, cand; /* minimum and candidate for minimum of quad. form */
-    double xmin, ymin;	/* coordinates of minimum */
-    int z;
-
-    /* let s be the vertex, in coordinates relative to x0/y0 */
-    s.x = pt[po[i]].x-x0;
-    s.y = pt[po[i]].y-y0;
-
-    /* intersect segments i-1 and i */
-
-    j = mod(i-1,m);
-
-    /* add quadratic forms */
-    for (l=0; l<3; l++) {
-      for (k=0; k<3; k++) {
-	Q[l][k] = q[j][l][k] + q[i][l][k];
-      }
-    }
-    
-    while(1) {
-      /* minimize the quadratic form Q on the unit square */
-      /* find intersection */
-
-#ifdef HAVE_GCC_LOOP_BUG
-      /* work around gcc bug #12243 */
-      free(NULL);
-#endif
-      
-      det = Q[0][0]*Q[1][1] - Q[0][1]*Q[1][0];
-      if (det != 0.0) {
-	w.x = (-Q[0][2]*Q[1][1] + Q[1][2]*Q[0][1]) / det;
-	w.y = ( Q[0][2]*Q[1][0] - Q[1][2]*Q[0][0]) / det;
-	break;
-      }
-
-      /* matrix is singular - lines are parallel. Add another,
-	 orthogonal axis, through the center of the unit square */
-      if (Q[0][0]>Q[1][1]) {
-	v[0] = -Q[0][1];
-	v[1] = Q[0][0];
-      } else if (Q[1][1]) {
-	v[0] = -Q[1][1];
-	v[1] = Q[1][0];
-      } else {
-	v[0] = 1;
-	v[1] = 0;
-      }
-      d = sq(v[0]) + sq(v[1]);
-      v[2] = - v[1] * s.y - v[0] * s.x;
-      for (l=0; l<3; l++) {
-	for (k=0; k<3; k++) {
-	  Q[l][k] += v[l] * v[k] / d;
-	}
-      }
-    }
-    dx = fabs(w.x-s.x);
-    dy = fabs(w.y-s.y);
-    if (dx <= .5 && dy <= .5) {
-      pp->curve.vertex[i].x = w.x+x0;
-      pp->curve.vertex[i].y = w.y+y0;
-      continue;
-    }
-
-    /* the minimum was not in the unit square; now minimize quadratic
-       on boundary of square */
-    min = quadform(Q, s);
-    xmin = s.x;
-    ymin = s.y;
-
-    if (Q[0][0] == 0.0) {
-      goto fixx;
-    }
-    for (z=0; z<2; z++) {   /* value of the y-coordinate */
-      w.y = s.y-0.5+z;
-      w.x = - (Q[0][1] * w.y + Q[0][2]) / Q[0][0];
-      dx = fabs(w.x-s.x);
-      cand = quadform(Q, w);
-      if (dx <= .5 && cand < min) {
-	min = cand;
-	xmin = w.x;
-	ymin = w.y;
-      }
-    }
-  fixx:
-    if (Q[1][1] == 0.0) {
-      goto corners;
-    }
-    for (z=0; z<2; z++) {   /* value of the x-coordinate */
-      w.x = s.x-0.5+z;
-      w.y = - (Q[1][0] * w.x + Q[1][2]) / Q[1][1];
-      dy = fabs(w.y-s.y);
-      cand = quadform(Q, w);
-      if (dy <= .5 && cand < min) {
-	min = cand;
-	xmin = w.x;
-	ymin = w.y;
-      }
-    }
-  corners:
-    /* check four corners */
-    for (l=0; l<2; l++) {
-      for (k=0; k<2; k++) {
-	w.x = s.x-0.5+l;
-	w.y = s.y-0.5+k;
-	cand = quadform(Q, w);
-	if (cand < min) {
-	  min = cand;
-	  xmin = w.x;
-	  ymin = w.y;
-	}
-      }
-    }
-
-    pp->curve.vertex[i].x = xmin + x0;
-    pp->curve.vertex[i].y = ymin + y0;
-    continue;
-  }
-
-  free(ctr);
-  free(dir);
-  free(q);
-  return 0;
-
- calloc_error:
-  free(ctr);
-  free(dir);
-  free(q);
-  return 1;
-}
-
-/* ---------------------------------------------------------------------- */
-/* Stage 4: smoothing and corner analysis (Sec. 2.3.3) */
-
-/* reverse orientation of a path */
-static void reverse(privcurve_t *curve) {
-  int m = curve->n;
-  int i, j;
-  dpoint_t tmp;
-
-  for (i=0, j=m-1; i<j; i++, j--) {
-    tmp = curve->vertex[i];
-    curve->vertex[i] = curve->vertex[j];
-    curve->vertex[j] = tmp;
-  }
-}
-
-/* Always succeeds */
-static void smooth(privcurve_t *curve, double alphamax) {
-  int m = curve->n;
-
-  int i, j, k;
-  double dd, denom, alpha;
-  dpoint_t p2, p3, p4;
-
-  /* examine each vertex and find its best fit */
-  for (i=0; i<m; i++) {
-    j = mod(i+1, m);
-    k = mod(i+2, m);
-    p4 = interval(1/2.0, curve->vertex[k], curve->vertex[j]);
-
-    denom = ddenom(curve->vertex[i], curve->vertex[k]);
-    if (denom != 0.0) {
-      dd = dpara(curve->vertex[i], curve->vertex[j], curve->vertex[k]) / denom;
-      dd = fabs(dd);
-      alpha = dd>1 ? (1 - 1.0/dd) : 0;
-      alpha = alpha / 0.75;
-    } else {
-      alpha = 4/3.0;
-    }
-    curve->alpha0[j] = alpha;	 /* remember "original" value of alpha */
-
-    if (alpha >= alphamax) {  /* pointed corner */
-      curve->tag[j] = POTRACE_CORNER;
-      curve->c[j][1] = curve->vertex[j];
-      curve->c[j][2] = p4;
-    } else {
-      if (alpha < 0.55) {
-	alpha = 0.55;
-      } else if (alpha > 1) {
-	alpha = 1;
-      }
-      p2 = interval(.5+.5*alpha, curve->vertex[i], curve->vertex[j]);
-      p3 = interval(.5+.5*alpha, curve->vertex[k], curve->vertex[j]);
-      curve->tag[j] = POTRACE_CURVETO;
-      curve->c[j][0] = p2;
-      curve->c[j][1] = p3;
-      curve->c[j][2] = p4;
-    }
-    curve->alpha[j] = alpha;	/* store the "cropped" value of alpha */
-    curve->beta[j] = 0.5;
-  }
-  curve->alphacurve = 1;
-
-  return;
-}
-
-/* ---------------------------------------------------------------------- */
-/* Stage 5: Curve optimization (Sec. 2.4) */
-
-/* a private type for the result of opti_penalty */
-struct opti_s {
-  double pen;	   /* penalty */
-  dpoint_t c[2];   /* curve parameters */
-  double t, s;	   /* curve parameters */
-  double alpha;	   /* curve parameter */
-};
-typedef struct opti_s opti_t;
-
-/* calculate best fit from i+.5 to j+.5.  Assume i<j (cyclically).
-   Return 0 and set badness and parameters (alpha, beta), if
-   possible. Return 1 if impossible. */
-static int opti_penalty(privpath_t *pp, int i, int j, opti_t *res, double opttolerance, int *convc, double *areac) {
-  int m = pp->curve.n;
-  int k, k1, k2, conv, i1;
-  double area, alpha, d, d1, d2;
-  dpoint_t p0, p1, p2, p3, pt;
-  double A, R, A1, A2, A3, A4;
-  double s, t;
-
-  /* check convexity, corner-freeness, and maximum bend < 179 degrees */
-
-  if (i==j) {  /* sanity - a full loop can never be an opticurve */
-    return 1;
-  }
-
-  k = i;
-  i1 = mod(i+1, m);
-  k1 = mod(k+1, m);
-  conv = convc[k1];
-  if (conv == 0) {
-    return 1;
-  }
-  d = ddist(pp->curve.vertex[i], pp->curve.vertex[i1]);
-  for (k=k1; k!=j; k=k1) {
-    k1 = mod(k+1, m);
-    k2 = mod(k+2, m);
-    if (convc[k1] != conv) {
-      return 1;
-    }
-    if (sign(cprod(pp->curve.vertex[i], pp->curve.vertex[i1], pp->curve.vertex[k1], pp->curve.vertex[k2])) != conv) {
-      return 1;
-    }
-    if (iprod1(pp->curve.vertex[i], pp->curve.vertex[i1], pp->curve.vertex[k1], pp->curve.vertex[k2]) < d * ddist(pp->curve.vertex[k1], pp->curve.vertex[k2]) * COS179) {
-      return 1;
-    }
-  }
-
-  /* the curve we're working in: */
-  p0 = pp->curve.c[mod(i,m)][2];
-  p1 = pp->curve.vertex[mod(i+1,m)];
-  p2 = pp->curve.vertex[mod(j,m)];
-  p3 = pp->curve.c[mod(j,m)][2];
-
-  /* determine its area */
-  area = areac[j] - areac[i];
-  area -= dpara(pp->curve.vertex[0], pp->curve.c[i][2], pp->curve.c[j][2])/2;
-  if (i>=j) {
-    area += areac[m];
-  }
-
-  /* find intersection o of p0p1 and p2p3. Let t,s such that o =
-     interval(t,p0,p1) = interval(s,p3,p2). Let A be the area of the
-     triangle (p0,o,p3). */
-
-  A1 = dpara(p0, p1, p2);
-  A2 = dpara(p0, p1, p3);
-  A3 = dpara(p0, p2, p3);
-  /* A4 = dpara(p1, p2, p3); */
-  A4 = A1+A3-A2;    
-  
-  if (A2 == A1) {  /* this should never happen */
-    return 1;
-  }
-
-  t = A3/(A3-A4);
-  s = A2/(A2-A1);
-  A = A2 * t / 2.0;
-  
-  if (A == 0.0) {  /* this should never happen */
-    return 1;
-  }
-
-  R = area / A;	 /* relative area */
-  alpha = 2 - sqrt(4 - R / 0.3);  /* overall alpha for p0-o-p3 curve */
-
-  res->c[0] = interval(t * alpha, p0, p1);
-  res->c[1] = interval(s * alpha, p3, p2);
-  res->alpha = alpha;
-  res->t = t;
-  res->s = s;
-
-  p1 = res->c[0];
-  p2 = res->c[1];  /* the proposed curve is now (p0,p1,p2,p3) */
-
-  res->pen = 0;
-
-  /* calculate penalty */
-  /* check tangency with edges */
-  for (k=mod(i+1,m); k!=j; k=k1) {
-    k1 = mod(k+1,m);
-    t = tangent(p0, p1, p2, p3, pp->curve.vertex[k], pp->curve.vertex[k1]);
-    if (t<-.5) {
-      return 1;
-    }
-    pt = bezier(t, p0, p1, p2, p3);
-    d = ddist(pp->curve.vertex[k], pp->curve.vertex[k1]);
-    if (d == 0.0) {  /* this should never happen */
-      return 1;
-    }
-    d1 = dpara(pp->curve.vertex[k], pp->curve.vertex[k1], pt) / d;
-    if (fabs(d1) > opttolerance) {
-      return 1;
-    }
-    if (iprod(pp->curve.vertex[k], pp->curve.vertex[k1], pt) < 0 || iprod(pp->curve.vertex[k1], pp->curve.vertex[k], pt) < 0) {
-      return 1;
-    }
-    res->pen += sq(d1);
-  }
-
-  /* check corners */
-  for (k=i; k!=j; k=k1) {
-    k1 = mod(k+1,m);
-    t = tangent(p0, p1, p2, p3, pp->curve.c[k][2], pp->curve.c[k1][2]);
-    if (t<-.5) {
-      return 1;
-    }
-    pt = bezier(t, p0, p1, p2, p3);
-    d = ddist(pp->curve.c[k][2], pp->curve.c[k1][2]);
-    if (d == 0.0) {  /* this should never happen */
-      return 1;
-    }
-    d1 = dpara(pp->curve.c[k][2], pp->curve.c[k1][2], pt) / d;
-    d2 = dpara(pp->curve.c[k][2], pp->curve.c[k1][2], pp->curve.vertex[k1]) / d;
-    d2 *= 0.75 * pp->curve.alpha[k1];
-    if (d2 < 0) {
-      d1 = -d1;
-      d2 = -d2;
-    }
-    if (d1 < d2 - opttolerance) {
-      return 1;
-    }
-    if (d1 < d2) {
-      res->pen += sq(d1 - d2);
-    }
-  }
-
-  return 0;
-}
-
-/* optimize the path p, replacing sequences of Bezier segments by a
-   single segment when possible. Return 0 on success, 1 with errno set
-   on failure. */
-static int opticurve(privpath_t *pp, double opttolerance) {
-  int m = pp->curve.n;
-  int *pt = NULL;     /* pt[m+1] */
-  double *pen = NULL; /* pen[m+1] */
-  int *len = NULL;    /* len[m+1] */
-  opti_t *opt = NULL; /* opt[m+1] */
-  int om;
-  int i,j,r;
-  opti_t o;
-  dpoint_t p0;
-  int i1;
-  double area;
-  double alpha;
-  double *s = NULL;
-  double *t = NULL;
-
-  int *convc = NULL; /* conv[m]: pre-computed convexities */
-  double *areac = NULL; /* cumarea[m+1]: cache for fast area computation */
-
-  SAFE_CALLOC(pt, m+1, int);
-  SAFE_CALLOC(pen, m+1, double);
-  SAFE_CALLOC(len, m+1, int);
-  SAFE_CALLOC(opt, m+1, opti_t);
-  SAFE_CALLOC(convc, m, int);
-  SAFE_CALLOC(areac, m+1, double);
-
-  /* pre-calculate convexity: +1 = right turn, -1 = left turn, 0 = corner */
-  for (i=0; i<m; i++) {
-    if (pp->curve.tag[i] == POTRACE_CURVETO) {
-      convc[i] = sign(dpara(pp->curve.vertex[mod(i-1,m)], pp->curve.vertex[i], pp->curve.vertex[mod(i+1,m)]));
-    } else {
-      convc[i] = 0;
-    }
-  }
-
-  /* pre-calculate areas */
-  area = 0.0;
-  areac[0] = 0.0;
-  p0 = pp->curve.vertex[0];
-  for (i=0; i<m; i++) {
-    i1 = mod(i+1, m);
-    if (pp->curve.tag[i1] == POTRACE_CURVETO) {
-      alpha = pp->curve.alpha[i1];
-      area += 0.3*alpha*(4-alpha)*dpara(pp->curve.c[i][2], pp->curve.vertex[i1], pp->curve.c[i1][2])/2;
-      area += dpara(p0, pp->curve.c[i][2], pp->curve.c[i1][2])/2;
-    }
-    areac[i+1] = area;
-  }
-
-  pt[0] = -1;
-  pen[0] = 0;
-  len[0] = 0;
-
-  /* Fixme: we always start from a fixed point -- should find the best
-     curve cyclically */
-
-  for (j=1; j<=m; j++) {
-    /* calculate best path from 0 to j */
-    pt[j] = j-1;
-    pen[j] = pen[j-1];
-    len[j] = len[j-1]+1;
-
-    for (i=j-2; i>=0; i--) {
-      r = opti_penalty(pp, i, mod(j,m), &o, opttolerance, convc, areac);
-      if (r) {
-	break;
-      }
-      if (len[j] > len[i]+1 || (len[j] == len[i]+1 && pen[j] > pen[i] + o.pen)) {
-	pt[j] = i;
-	pen[j] = pen[i] + o.pen;
-	len[j] = len[i] + 1;
-	opt[j] = o;
-      }
-    }
-  }
-  om = len[m];
-  r = privcurve_init(&pp->ocurve, om);
-  if (r) {
-    goto calloc_error;
-  }
-  SAFE_CALLOC(s, om, double);
-  SAFE_CALLOC(t, om, double);
-
-  j = m;
-  for (i=om-1; i>=0; i--) {
-    if (pt[j]==j-1) {
-      pp->ocurve.tag[i]     = pp->curve.tag[mod(j,m)];
-      pp->ocurve.c[i][0]    = pp->curve.c[mod(j,m)][0];
-      pp->ocurve.c[i][1]    = pp->curve.c[mod(j,m)][1];
-      pp->ocurve.c[i][2]    = pp->curve.c[mod(j,m)][2];
-      pp->ocurve.vertex[i]  = pp->curve.vertex[mod(j,m)];
-      pp->ocurve.alpha[i]   = pp->curve.alpha[mod(j,m)];
-      pp->ocurve.alpha0[i]  = pp->curve.alpha0[mod(j,m)];
-      pp->ocurve.beta[i]    = pp->curve.beta[mod(j,m)];
-      s[i] = t[i] = 1.0;
-    } else {
-      pp->ocurve.tag[i] = POTRACE_CURVETO;
-      pp->ocurve.c[i][0] = opt[j].c[0];
-      pp->ocurve.c[i][1] = opt[j].c[1];
-      pp->ocurve.c[i][2] = pp->curve.c[mod(j,m)][2];
-      pp->ocurve.vertex[i] = interval(opt[j].s, pp->curve.c[mod(j,m)][2], pp->curve.vertex[mod(j,m)]);
-      pp->ocurve.alpha[i] = opt[j].alpha;
-      pp->ocurve.alpha0[i] = opt[j].alpha;
-      s[i] = opt[j].s;
-      t[i] = opt[j].t;
-    }
-    j = pt[j];
-  }
-
-  /* calculate beta parameters */
-  for (i=0; i<om; i++) {
-    i1 = mod(i+1,om);
-    pp->ocurve.beta[i] = s[i] / (s[i] + t[i1]);
-  }
-  pp->ocurve.alphacurve = 1;
-
-  free(pt);
-  free(pen);
-  free(len);
-  free(opt);
-  free(s);
-  free(t);
-  free(convc);
-  free(areac);
-  return 0;
-
- calloc_error:
-  free(pt);
-  free(pen);
-  free(len);
-  free(opt);
-  free(s);
-  free(t);
-  free(convc);
-  free(areac);
-  return 1;
-}
-
-/* ---------------------------------------------------------------------- */
-
-#define TRY(x) if (x) goto try_error
-
-/* return 0 on success, 1 on error with errno set. */
-int process_path(path_t *plist, const potrace_param_t *param, progress_t *progress) {
-  path_t *p;
-  double nn = 0, cn = 0;
-
-  if (progress->callback) {
-    /* precompute task size for progress estimates */
-    nn = 0;
-    list_forall (p, plist) {
-      nn += p->priv->len;
-    }
-    cn = 0;
-  }
-  
-  /* call downstream function with each path */
-  list_forall (p, plist) {
-    TRY(calc_sums(p->priv));
-    TRY(calc_lon(p->priv));
-    TRY(bestpolygon(p->priv));
-    TRY(adjust_vertices(p->priv));
-    if (p->sign == '-') {   /* reverse orientation of negative paths */
-      reverse(&p->priv->curve);
-    }
-    smooth(&p->priv->curve, param->alphamax);
-    if (param->opticurve) {
-      TRY(opticurve(p->priv, param->opttolerance));
-      p->priv->fcurve = &p->priv->ocurve;
-    } else {
-      p->priv->fcurve = &p->priv->curve;
-    }
-    privcurve_to_curve(p->priv->fcurve, &p->curve);
-
-    if (progress->callback) {
-      cn += p->priv->len;
-      progress_update(cn/nn, progress);
-    }
-  }
-
-  progress_update(1.0, progress);
-
-  return 0;
-
- try_error:
-  return 1;
-}
 
=== removed file 'src/trace/potrace/trace.h'
--- src/trace/potrace/trace.h	2015-03-31 10:33:40 +0000
+++ src/trace/potrace/trace.h	1970-01-01 00:00:00 +0000
@@ -1,15 +0,0 @@
-/* Copyright (C) 2001-2015 Peter Selinger.
-   This file is part of Potrace. It is free software and it is covered
-   by the GNU General Public License. See the file COPYING for details. */
-
-
-#ifndef TRACE_H
-#define TRACE_H
-
-#include "potracelib.h"
-#include "progress.h"
-#include "curve.h"
-
-int process_path(path_t *plist, const potrace_param_t *param, progress_t *progress);
-
-#endif /* TRACE_H */
 
=== modified file 'src/ui/CMakeLists.txt'
--- src/ui/CMakeLists.txt	2015-06-08 19:01:23 +0000
+++ src/ui/CMakeLists.txt	2015-11-21 12:39:21 +0000
@@ -34,7 +34,6 @@
 	tools/dropper-tool.cpp
 	tools/dynamic-base.cpp
 	tools/eraser-tool.cpp
-	tools/flood-tool.cpp
 	tools/freehand-base.cpp
 	tools/gradient-tool.cpp
 	tools/lpe-tool.cpp
@@ -107,7 +106,6 @@
 	dialog/template-widget.cpp
 	dialog/text-edit.cpp
 	dialog/tile.cpp
-	dialog/tracedialog.cpp
 	dialog/transformation.cpp
 	dialog/undo-history.cpp
 	dialog/xml-tree.cpp
@@ -248,7 +246,6 @@
 	dialog/template-widget.h
 	dialog/text-edit.h
 	dialog/tile.h
-	dialog/tracedialog.h
 	dialog/transformation.h
 	dialog/undo-history.h
 	dialog/xml-tree.h
@@ -276,7 +273,6 @@
 	tools/dropper-tool.h
 	tools/dynamic-base.h
 	tools/eraser-tool.h
-	tools/flood-tool.h
 	tools/freehand-base.h
 	tools/gradient-tool.h
 	tools/lpe-tool.h
@@ -364,3 +360,14 @@
 
 # add_inkscape_lib(ui_LIB "${ui_SRC}")
 add_inkscape_source("${ui_SRC}")
+
+set ( ui_flood_and_trace_SRC
+	tools/flood-tool.h
+	tools/flood-tool.cpp
+	dialog/tracedialog.cpp
+	dialog/tracedialog.h
+)
+
+if ("${HAVE_POTRACE}")
+	add_inkscape_source("${ui_flood_and_trace_SRC}")
+endif()
 
=== modified file 'src/ui/dialog/Makefile_insert'
--- src/ui/dialog/Makefile_insert	2014-11-09 05:13:46 +0000
+++ src/ui/dialog/Makefile_insert	2015-11-21 12:39:21 +0000
@@ -106,8 +106,6 @@
 	ui/dialog/text-edit.h			\
 	ui/dialog/tile.cpp			\
 	ui/dialog/tile.h			\
-	ui/dialog/tracedialog.cpp		\
-	ui/dialog/tracedialog.h			\
 	ui/dialog/pixelartdialog.cpp		\
 	ui/dialog/pixelartdialog.h		\
 	ui/dialog/transformation.cpp		\
@@ -123,3 +121,11 @@
 	ui/dialog/lpe-fillet-chamfer-properties.cpp		\
 	ui/dialog/lpe-fillet-chamfer-properties.h		\
 	$(inkboard_dialogs)
+
+if HAVE_POTRACE
+
+ink_common_sources +=		\
+	ui/dialog/tracedialog.cpp		\
+	ui/dialog/tracedialog.h
+
+endif
 
=== modified file 'src/ui/dialog/dialog-manager.cpp'
--- src/ui/dialog/dialog-manager.cpp	2014-10-08 02:22:03 +0000
+++ src/ui/dialog/dialog-manager.cpp	2015-11-21 12:39:21 +0000
@@ -34,7 +34,11 @@
 #include "ui/dialog/messages.h"
 #include "ui/dialog/symbols.h"
 #include "ui/dialog/tile.h"
-#include "ui/dialog/tracedialog.h"
+
+#if HAVE_POTRACE
+# include "ui/dialog/tracedialog.h"
+#endif
+
 #include "ui/dialog/pixelartdialog.h"
 #include "ui/dialog/transformation.h"
 #include "ui/dialog/undo-history.h"
@@ -124,7 +128,11 @@
         registerFactory("Swatches",            &create<SwatchesPanel,        FloatingBehavior>);
         registerFactory("TileDialog",          &create<ArrangeDialog,        FloatingBehavior>);
         registerFactory("Symbols",             &create<SymbolsDialog,        FloatingBehavior>);
+
+#if HAVE_POTRACE
         registerFactory("Trace",               &create<TraceDialog,          FloatingBehavior>);
+#endif
+
         registerFactory("PixelArt",            &create<PixelArtDialog,       FloatingBehavior>);
         registerFactory("Transformation",      &create<Transformation,       FloatingBehavior>);
         registerFactory("UndoHistory",         &create<UndoHistory,          FloatingBehavior>);
@@ -159,7 +167,11 @@
         registerFactory("Swatches",            &create<SwatchesPanel,        DockBehavior>);
         registerFactory("TileDialog",          &create<ArrangeDialog,        DockBehavior>);
         registerFactory("Symbols",             &create<SymbolsDialog,        DockBehavior>);
+
+#if HAVE_POTRACE
         registerFactory("Trace",               &create<TraceDialog,          DockBehavior>);
+#endif
+
         registerFactory("PixelArt",            &create<PixelArtDialog,       DockBehavior>);
         registerFactory("Transformation",      &create<Transformation,       DockBehavior>);
         registerFactory("UndoHistory",         &create<UndoHistory,          DockBehavior>);
 
=== modified file 'src/ui/dialog/inkscape-preferences.cpp'
--- src/ui/dialog/inkscape-preferences.cpp	2015-11-01 12:50:42 +0000
+++ src/ui/dialog/inkscape-preferences.cpp	2015-11-21 12:39:21 +0000
@@ -478,10 +478,12 @@
     this->AddPage(_page_eraser, _("Eraser"), iter_tools, PREFS_PAGE_TOOLS_ERASER);
     this->AddNewObjectsStyle(_page_eraser, "/tools/eraser");
 
+#if HAVE_POTRACE
     //Paint Bucket
     this->AddPage(_page_paintbucket, _("Paint Bucket"), iter_tools, PREFS_PAGE_TOOLS_PAINTBUCKET);
     this->AddSelcueCheckbox(_page_paintbucket, "/tools/paintbucket", false);
     this->AddNewObjectsStyle(_page_paintbucket, "/tools/paintbucket");
+#endif
 
     //Gradient
     this->AddPage(_page_gradient, _("Gradient"), iter_tools, PREFS_PAGE_TOOLS_GRADIENT);
 
=== modified file 'src/ui/dialog/inkscape-preferences.h'
--- src/ui/dialog/inkscape-preferences.h	2015-07-24 19:38:06 +0000
+++ src/ui/dialog/inkscape-preferences.h	2015-11-21 12:39:21 +0000
@@ -15,6 +15,10 @@
 #ifndef INKSCAPE_UI_DIALOG_INKSCAPE_PREFERENCES_H
 #define INKSCAPE_UI_DIALOG_INKSCAPE_PREFERENCES_H
 
+#if HAVE_CONFIG_H
+# include "config.h"
+#endif
+
 #include <iostream>
 #include <vector>
 #include "ui/widget/preferences-widget.h"
@@ -56,7 +60,11 @@
     PREFS_PAGE_TOOLS_TEXT,
     PREFS_PAGE_TOOLS_SPRAY,
     PREFS_PAGE_TOOLS_ERASER,
+
+#if HAVE_POTRACE
     PREFS_PAGE_TOOLS_PAINTBUCKET,
+#endif
+
     PREFS_PAGE_TOOLS_GRADIENT,
     PREFS_PAGE_TOOLS_DROPPER,
     PREFS_PAGE_TOOLS_CONNECTOR,
 
=== modified file 'src/ui/tool-factory.cpp'
--- src/ui/tool-factory.cpp	2015-02-25 01:04:28 +0000
+++ src/ui/tool-factory.cpp	2015-11-21 12:39:21 +0000
@@ -16,7 +16,11 @@
 #include "ui/tools/connector-tool.h"
 #include "ui/tools/dropper-tool.h"
 #include "ui/tools/eraser-tool.h"
-#include "ui/tools/flood-tool.h"
+
+#if HAVE_POTRACE
+# include "ui/tools/flood-tool.h"
+#endif
+
 #include "ui/tools/gradient-tool.h"
 #include "ui/tools/lpe-tool.h"
 #include "ui/tools/measure-tool.h"
@@ -52,8 +56,10 @@
         tool = new DropperTool;
     else if (id == "/tools/eraser")
         tool = new EraserTool;
+#if HAVE_POTRACE
     else if (id == "/tools/paintbucket")
         tool = new FloodTool;
+#endif
     else if (id == "/tools/gradient")
         tool = new GradientTool;
     else if (id == "/tools/lpetool")
 
=== modified file 'src/ui/tools-switch.h'
--- src/ui/tools-switch.h	2014-10-05 23:24:27 +0000
+++ src/ui/tools-switch.h	2015-11-21 12:39:21 +0000
@@ -12,6 +12,10 @@
 #ifndef SEEN_TOOLS_SWITCH_H
 #define SEEN_TOOLS_SWITCH_H
 
+#if HAVE_CONFIG_H
+# include "config.h"
+#endif
+
 class SPDesktop;
 class SPItem;
 namespace Geom {
@@ -40,7 +44,11 @@
   TOOLS_MEASURE,
   TOOLS_DROPPER,
   TOOLS_CONNECTOR,
+
+#if HAVE_POTRACE
   TOOLS_PAINTBUCKET,
+#endif
+
   TOOLS_ERASER,
   TOOLS_LPETOOL
 };
 
=== modified file 'src/ui/tools/Makefile_insert'
--- src/ui/tools/Makefile_insert	2013-11-09 22:36:13 +0000
+++ src/ui/tools/Makefile_insert	2015-11-21 12:39:21 +0000
@@ -8,7 +8,6 @@
 	ui/tools/dropper-tool.cpp ui/tools/dropper-tool.h				\
 	ui/tools/dynamic-base.cpp ui/tools/dynamic-base.h				\
 	ui/tools/eraser-tool.cpp ui/tools/eraser-tool.h					\
-	ui/tools/flood-tool.cpp ui/tools/flood-tool.h					\
 	ui/tools/freehand-base.cpp ui/tools/freehand-base.h				\
 	ui/tools/gradient-tool.cpp ui/tools/gradient-tool.h				\
 	ui/tools/lpe-tool.cpp ui/tools/lpe-tool.h						\
@@ -25,4 +24,11 @@
 	ui/tools/text-tool.cpp ui/tools/text-tool.h						\
 	ui/tools/tool-base.cpp ui/tools/tool-base.h						\
 	ui/tools/tweak-tool.cpp ui/tools/tweak-tool.h					\
-	ui/tools/zoom-tool.cpp ui/tools/zoom-tool.h
 \ No newline at end of file
+	ui/tools/zoom-tool.cpp ui/tools/zoom-tool.h
+
+if HAVE_POTRACE
+
+ink_common_sources += \
+	ui/tools/flood-tool.cpp ui/tools/flood-tool.h
+
+endif
 
=== modified file 'src/verbs.cpp'
--- src/verbs.cpp	2015-05-09 12:59:00 +0000
+++ src/verbs.cpp	2015-11-21 12:39:21 +0000
@@ -832,7 +832,14 @@
         verb = verb_found->second;
     }
 
-    if (verb == NULL)
+    if (verb == NULL
+#if !HAVE_POTRACE
+                // Squash warning about disabled features
+                && strcmp(id, "ToolPaintBucket")  != 0
+                && strcmp(id, "SelectionTrace")   != 0
+                && strcmp(id, "PaintBucketPrefs") != 0
+#endif
+            )
         printf("Unable to find: %s\n", id);
 
     return verb;
@@ -1201,10 +1208,14 @@
         case SP_VERB_SELECTION_REVERSE:
             SelectionHelper::reverse(dt);
             break;
+
+#if HAVE_POTRACE
         case SP_VERB_SELECTION_TRACE:
             INKSCAPE.dialogs_unhide();
             dt->_dlg_mgr->showDialog("Trace");
             break;
+#endif
+
         case SP_VERB_SELECTION_PIXEL_ART:
             INKSCAPE.dialogs_unhide();
             dt->_dlg_mgr->showDialog("PixelArt");
@@ -1606,7 +1617,7 @@
     /** \todo !!! hopefully this can go away soon and actions can look after
      * themselves
      */
-    for (vidx = SP_VERB_CONTEXT_SELECT; vidx <= SP_VERB_CONTEXT_PAINTBUCKET_PREFS; vidx++)
+    for (vidx = SP_VERB_CONTEXT_SELECT; vidx <= SP_VERB_CONTEXT_LPETOOL_PREFS; vidx++)
     {
         SPAction *tool_action= get((sp_verb_t)vidx)->get_action(action->context);
         if (tool_action) {
@@ -1673,9 +1684,13 @@
         case SP_VERB_CONTEXT_CONNECTOR:
             tools_switch(dt,  TOOLS_CONNECTOR);
             break;
+
+#if HAVE_POTRACE
         case SP_VERB_CONTEXT_PAINTBUCKET:
             tools_switch(dt, TOOLS_PAINTBUCKET);
             break;
+#endif
+
         case SP_VERB_CONTEXT_ERASER:
             tools_switch(dt, TOOLS_ERASER);
             break;
@@ -1759,10 +1774,14 @@
             prefs->setInt("/dialogs/preferences/page", PREFS_PAGE_TOOLS_CONNECTOR);
             dt->_dlg_mgr->showDialog("InkscapePreferences");
             break;
+
+#if HAVE_POTRACE
         case SP_VERB_CONTEXT_PAINTBUCKET_PREFS:
             prefs->setInt("/dialogs/preferences/page", PREFS_PAGE_TOOLS_PAINTBUCKET);
             dt->_dlg_mgr->showDialog("InkscapePreferences");
             break;
+#endif
+
         case SP_VERB_CONTEXT_ERASER_PREFS:
             prefs->setInt("/dialogs/preferences/page", PREFS_PAGE_TOOLS_ERASER);
             dt->_dlg_mgr->showDialog("InkscapePreferences");
@@ -2160,10 +2179,14 @@
             // TRANSLATORS: See "tutorial-basic.svg" comment.
             sp_help_open_tutorial(NULL, (gpointer)_("tutorial-advanced.svg"));
             break;
+
+#if HAVE_POTRACE
         case SP_VERB_TUTORIAL_TRACING:
             // TRANSLATORS: See "tutorial-basic.svg" comment.
             sp_help_open_tutorial(NULL, (gpointer)_("tutorial-tracing.svg"));
             break;
+#endif
+
         case SP_VERB_TUTORIAL_TRACING_PIXELART:
             sp_help_open_tutorial(NULL, (gpointer)_("tutorial-tracing-pixelart.svg"));
             break;
@@ -2593,9 +2616,13 @@
                       N_("Simplify selected paths (remove extra nodes)"), INKSCAPE_ICON("path-simplify")),
     new SelectionVerb(SP_VERB_SELECTION_REVERSE, "SelectionReverse", N_("_Reverse"),
                       N_("Reverse the direction of selected paths (useful for flipping markers)"), INKSCAPE_ICON("path-reverse")),
+
+#if HAVE_POTRACE
     // TRANSLATORS: "to trace" means "to convert a bitmap to vector graphics" (to vectorize)
     new SelectionVerb(SP_VERB_SELECTION_TRACE, "SelectionTrace", N_("_Trace Bitmap..."),
                       N_("Create one or more paths from a bitmap by tracing it"), INKSCAPE_ICON("bitmap-trace")),
+#endif
+
     new SelectionVerb(SP_VERB_SELECTION_PIXEL_ART, "SelectionPixelArt", N_("Trace Pixel Art..."),
                       N_("Create paths using Kopf-Lischinski algorithm to vectorize pixel art"), INKSCAPE_ICON("pixelart-trace")),
     new SelectionVerb(SP_VERB_SELECTION_CREATE_BITMAP, "SelectionCreateBitmap", N_("Make a _Bitmap Copy"),
@@ -2733,8 +2760,12 @@
                     N_("Pick colors from image"), INKSCAPE_ICON("color-picker")),
     new ContextVerb(SP_VERB_CONTEXT_CONNECTOR, "ToolConnector", NC_("ContextVerb", "Connector"),
                     N_("Create diagram connectors"), INKSCAPE_ICON("draw-connector")),
+
+#if HAVE_POTRACE
     new ContextVerb(SP_VERB_CONTEXT_PAINTBUCKET, "ToolPaintBucket", NC_("ContextVerb", "Paint Bucket"),
                     N_("Fill bounded areas"), INKSCAPE_ICON("color-fill")),
+#endif
+
     new ContextVerb(SP_VERB_CONTEXT_LPE, "ToolLPE", NC_("ContextVerb", "LPE Edit"),
                     N_("Edit Path Effect parameters"), NULL),
     new ContextVerb(SP_VERB_CONTEXT_ERASER, "ToolEraser", NC_("ContextVerb", "Eraser"),
@@ -2780,8 +2811,12 @@
                     N_("Open Preferences for the Dropper tool"), NULL),
     new ContextVerb(SP_VERB_CONTEXT_CONNECTOR_PREFS, "ConnectorPrefs", N_("Connector Preferences"),
                     N_("Open Preferences for the Connector tool"), NULL),
+
+#if HAVE_POTRACE
     new ContextVerb(SP_VERB_CONTEXT_PAINTBUCKET_PREFS, "PaintBucketPrefs", N_("Paint Bucket Preferences"),
                     N_("Open Preferences for the Paint Bucket tool"), NULL),
+#endif
+
     new ContextVerb(SP_VERB_CONTEXT_ERASER_PREFS, "EraserPrefs", N_("Eraser Preferences"),
                     N_("Open Preferences for the Eraser tool"), NULL),
     new ContextVerb(SP_VERB_CONTEXT_LPETOOL_PREFS, "LPEToolPrefs", N_("LPE Tool Preferences"),
@@ -2937,9 +2972,13 @@
                      N_("Using shape tools to create and edit shapes"), NULL),
     new TutorialVerb(SP_VERB_TUTORIAL_ADVANCED, "TutorialsAdvanced", N_("Inkscape: _Advanced"),
                      N_("Advanced Inkscape topics"), NULL/*"tutorial_advanced"*/),
+
+#if HAVE_POTRACE
     // TRANSLATORS: "to trace" means "to convert a bitmap to vector graphics" (to vectorize)
     new TutorialVerb(SP_VERB_TUTORIAL_TRACING, "TutorialsTracing", N_("Inkscape: T_racing"),
                      N_("Using bitmap tracing"), NULL/*"tutorial_tracing"*/),
+#endif
+
     new TutorialVerb(SP_VERB_TUTORIAL_TRACING_PIXELART, "TutorialsTracingPixelArt", N_("Inkscape: Tracing Pixel Art"),
                      N_("Using Trace Pixel Art dialog"), NULL),
     new TutorialVerb(SP_VERB_TUTORIAL_CALLIGRAPHY, "TutorialsCalligraphy", N_("Inkscape: _Calligraphy"),
 
=== modified file 'src/verbs.h'
--- src/verbs.h	2014-10-08 02:22:03 +0000
+++ src/verbs.h	2015-11-21 12:39:21 +0000
@@ -136,7 +136,11 @@
     SP_VERB_SELECTION_OUTLINE,
     SP_VERB_SELECTION_SIMPLIFY,
     SP_VERB_SELECTION_REVERSE,
+
+#if HAVE_POTRACE
     SP_VERB_SELECTION_TRACE,
+#endif
+
     SP_VERB_SELECTION_PIXEL_ART,
     SP_VERB_SELECTION_CREATE_BITMAP,
     SP_VERB_SELECTION_COMBINE,
@@ -203,7 +207,11 @@
     SP_VERB_CONTEXT_MEASURE,
     SP_VERB_CONTEXT_DROPPER,
     SP_VERB_CONTEXT_CONNECTOR,
+
+#if HAVE_POTRACE
     SP_VERB_CONTEXT_PAINTBUCKET,
+#endif
+
     SP_VERB_CONTEXT_LPE, /* not really a tool but used for editing LPE parameters on-canvas for example */
     SP_VERB_CONTEXT_ERASER,
     SP_VERB_CONTEXT_LPETOOL, /* note that this is very different from SP_VERB_CONTEXT_LPE above! */
@@ -227,7 +235,11 @@
     SP_VERB_CONTEXT_MEASURE_PREFS,
     SP_VERB_CONTEXT_DROPPER_PREFS,
     SP_VERB_CONTEXT_CONNECTOR_PREFS,
+
+#if HAVE_POTRACE
     SP_VERB_CONTEXT_PAINTBUCKET_PREFS,
+#endif
+
     SP_VERB_CONTEXT_ERASER_PREFS,
     SP_VERB_CONTEXT_LPETOOL_PREFS,
     /* Zooming and desktop settings */
@@ -311,7 +323,11 @@
     SP_VERB_TUTORIAL_BASIC,
     SP_VERB_TUTORIAL_SHAPES,
     SP_VERB_TUTORIAL_ADVANCED,
+
+#if HAVE_POTRACE
     SP_VERB_TUTORIAL_TRACING,
+#endif
+
     SP_VERB_TUTORIAL_TRACING_PIXELART,
     SP_VERB_TUTORIAL_CALLIGRAPHY,
     SP_VERB_TUTORIAL_INTERPOLATE,
 
=== modified file 'src/widgets/CMakeLists.txt'
--- src/widgets/CMakeLists.txt	2015-04-26 17:51:08 +0000
+++ src/widgets/CMakeLists.txt	2015-11-21 12:39:21 +0000
@@ -11,7 +11,6 @@
 	  measure-toolbar.cpp
 	  mesh-toolbar.cpp
 	  node-toolbar.cpp
-	  paintbucket-toolbar.cpp
 	  pencil-toolbar.cpp
 	  rect-toolbar.cpp
 	  spiral-toolbar.cpp
@@ -67,7 +66,6 @@
 	  measure-toolbar.h
 	  mesh-toolbar.h
 	  node-toolbar.h
-	  paintbucket-toolbar.h
 	  pencil-toolbar.h
 	  rect-toolbar.h
 	  spiral-toolbar.h
@@ -114,3 +112,12 @@
 
 # add_inkscape_lib(widgets_LIB "${widgets_SRC}")
 add_inkscape_source("${widgets_SRC}")
+
+set ( widgets_paintbucket_SRC
+	  paintbucket-toolbar.cpp
+	  paintbucket-toolbar.h
+)
+
+if ("${HAVE_POTRACE}")
+	add_inkscape_source("${widgets_paintbucket_SRC}")
+endif()
 
=== modified file 'src/widgets/Makefile_insert'
--- src/widgets/Makefile_insert	2015-04-26 17:51:08 +0000
+++ src/widgets/Makefile_insert	2015-11-21 12:39:21 +0000
@@ -58,8 +58,6 @@
 	widgets/node-toolbar.h	\
 	widgets/paint-selector.cpp	\
 	widgets/paint-selector.h	\
-	widgets/paintbucket-toolbar.cpp	\
-	widgets/paintbucket-toolbar.h	\
 	widgets/pencil-toolbar.cpp	\
 	widgets/pencil-toolbar.h	   \
 	widgets/rect-toolbar.cpp	\
@@ -109,5 +107,13 @@
 	widgets/zoom-toolbar.h \
 	widgets/widget-sizes.h
 
+if HAVE_POTRACE
+
+ink_common_sources +=	\
+	widgets/paintbucket-toolbar.cpp	\
+	widgets/paintbucket-toolbar.h
+
+endif
+
 widgets/button.$(OBJEXT): helper/sp-marshal.h
 widgets/menu.$(OBJEXT): helper/sp-marshal.h
 
=== modified file 'src/widgets/toolbox.cpp'
--- src/widgets/toolbox.cpp	2015-11-12 23:48:16 +0000
+++ src/widgets/toolbox.cpp	2015-11-21 12:39:21 +0000
@@ -79,7 +79,11 @@