Application: gvSIG desktop » gvSIG 3D

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2005 IVER T.I. and Generalitat Valenciana.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 */

package org.gvsig.jpotrace;

/**

 * La clase <code>PotraceException</code> es una forma de expresar que un

 * parametro ha sido mal usado en la libreria de jpotrace

 * @version 31/07/2008

 * @author BorSanZa - Borja S?nchez Zamorano (borja.sanchez@iver.es)

 */

public class PotraceException extends Exception {

	private static final long serialVersionUID = -5761750440639572006L;

	public PotraceException(String msg) {

		super(msg);

	}

}

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2005 IVER T.I. and Generalitat Valenciana.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 */

package org.gvsig.jpotrace;

/**

 * La clase <code>Potrace</code> contiene los metodos que comunican la libreria

 * nativa con Java

 *  

 * @version 31/07/2008

 * @author BorSanZa - Borja S?nchez Zamorano (borja.sanchez@iver.es)

 */

public class Potrace extends JNIBase {

	private static native double[] vectorizeBufferRasterNat(int[] bufferIn, int width, int height, String[] params);

	/**

	 * Vectoriza un buffer pasado por parametro y es devuelto en forma de array

	 * de doubles. Hay que especificar el ancho y alto del buffer y el buffer ha

	 * de ser pasado en el formato que soporta potrace, que es en forma de bits.

	 * 

	 * El parametro params es un array de Strings como se usaria en el tipico

	 * main(char[]) para expresar los parametros de potrace, es una forma de poder

	 * aprovechar todos los parametros del comando potrace desde Java. Algunos 

	 * no funcionan, como especificar el fichero origen o destino

	 * 

	 * @param bufferIn

	 * @param width

	 * @param height

	 * @param params

	 * @return

	 * @throws PotraceException

	 */

	public static double[] vectorizeBufferRaster(int[] bufferIn, int width, int height, String[] params) throws PotraceException {

		if (bufferIn == null)

			throw new PotraceException("El parametro Buffer no puede estar vacio");

		if (width <= 0)

			throw new PotraceException("El ancho del buffer ha de ser mayor a 0");

		if (height <= 0)

			throw new PotraceException("El alto del buffer ha de ser mayor a 0");

		return vectorizeBufferRasterNat(bufferIn, width, height, params);

	}

}

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2005 IVER T.I. and Generalitat Valenciana.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 */

package org.gvsig.jpotrace;

/**

 * La clase <code>JNIBase</code> sirve para cargar la libreria de jpotrace

 * 

 * @version 31/07/2008

 * @author BorSanZa - Borja S?nchez Zamorano (borja.sanchez@iver.es)

 */

public class JNIBase {

	static {

		String os = System.getProperty("os.name");

		if (os.toLowerCase().startsWith("windows"))

			System.loadLibrary("jpotrace001");

		else

			System.loadLibrary("jpotrace");

	}

}

/* Copyright (C) 2001-2007 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 BITMAP_H

#define BITMAP_H

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <string.h>

#include <stdlib.h>

/* The bitmap type is defined in potracelib.h */

#include "potracelib.h"

/* The present file defines some convenient macros and static inline

   functions for accessing bitmaps. Since they only produce inline

   code, they can be conveniently shared by the library and frontends,

   if desired */

/* ---------------------------------------------------------------------- */

/* some measurements */

#define BM_WORDSIZE ((int)sizeof(potrace_word))

#define BM_WORDBITS (8*BM_WORDSIZE)

#define BM_HIBIT (((potrace_word)1)<<(BM_WORDBITS-1))

#define BM_ALLBITS (~(potrace_word)0)

/* macros for accessing pixel at index (x,y). U* macros omit the

   bounds check. */

#define bm_scanline(bm, y) ((bm)->map + (y)*(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))

#define bm_safe(bm, x, y) (bm_range(x, (bm)->w) && bm_range(y, (bm)->h))

#define BM_UGET(bm, x, y) ((*bm_index(bm, x, y) & bm_mask(x)) != 0)

#define BM_USET(bm, x, y) (*bm_index(bm, x, y) |= bm_mask(x))

#define BM_UCLR(bm, x, y) (*bm_index(bm, x, y) &= ~bm_mask(x))

#define BM_UINV(bm, x, y) (*bm_index(bm, x, y) ^= bm_mask(x))

#define BM_UPUT(bm, x, y, b) ((b) ? BM_USET(bm, x, y) : BM_UCLR(bm, x, y))

#define BM_GET(bm, x, y) (bm_safe(bm, x, y) ? BM_UGET(bm, x, y) : 0)

#define BM_SET(bm, x, y) (bm_safe(bm, x, y) ? BM_USET(bm, x, y) : 0)

#define BM_CLR(bm, x, y) (bm_safe(bm, x, y) ? BM_UCLR(bm, x, y) : 0)

#define BM_INV(bm, x, y) (bm_safe(bm, x, y) ? BM_UINV(bm, x, y) : 0)

#define BM_PUT(bm, x, y, b) (bm_safe(bm, x, y) ? BM_UPUT(bm, x, y, b) : 0)

/* free the given bitmap. Leaves errno untouched. */

static inline void bm_free(potrace_bitmap_t *bm) {

  if (bm) {

    free(bm->map);

  }

  free(bm);

}

/* return new un-initialized bitmap. NULL with errno on error */

static inline potrace_bitmap_t *bm_new(int w, int h) {

  potrace_bitmap_t *bm;

  int dy = (w + BM_WORDBITS - 1) / BM_WORDBITS;

  bm = (potrace_bitmap_t *) malloc(sizeof(potrace_bitmap_t));

  if (!bm) {

    return NULL;

  }

  bm->w = w;

  bm->h = h;

  bm->dy = dy;

  bm->map = (potrace_word *) malloc(dy * h * BM_WORDSIZE);

  if (!bm->map) {

    free(bm);

    return NULL;

  }

  return bm;

}

/* clear the given bitmap. Set all bits to c. */

static inline void bm_clear(potrace_bitmap_t *bm, int c) {

  memset(bm->map, c ? -1 : 0, bm->dy * bm->h * BM_WORDSIZE);

}

/* 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);

  if (!bm1) {

    return NULL;

  }

  memcpy(bm1->map, bm->map, bm->dy * bm->h * BM_WORDSIZE);

  return bm1;

}

/* invert the given bitmap. */

static inline void bm_invert(potrace_bitmap_t *bm) {

  int i;

  for (i = 0; i < bm->dy * bm->h; i++) {

    bm->map[i] ^= BM_ALLBITS;

  }

}

#endif /* BITMAP_H */

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2005 IVER T.I. and Generalitat Valenciana.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 */

#ifndef POTRACE_RASTER_H

#define POTRACE_RASTER_H

#include "potracelib.h"

/* structure to hold a tilted rectangle */

struct rect_s {

	double bb[2];    /* dimensions of bounding box */

	double orig[2];  /* origin relative to bounding box */

};

typedef struct rect_s rect_t;

#ifdef USE_A4

#define DEFAULT_PAPERWIDTH 595

#define DEFAULT_PAPERHEIGHT 842

#define DEFAULT_PAPERFORMAT "a4"

#else

#define DEFAULT_PAPERWIDTH 612

#define DEFAULT_PAPERHEIGHT 792

#define DEFAULT_PAPERFORMAT "letter"

#endif

/* structure to hold a dimensioned value */

struct dim_s {

	double x; /* value */

	double d; /* dimension (in pt), or 0 if not given */

};

typedef struct dim_s dim_t;

/* structure to hold command line options */

struct info_s {

	struct backend_s *backend;  /* type of backend (eps,ps,pgm etc) */

	potrace_param_t *param;  /* tracing parameters, see potracelib.h */

	int debug;         /* type of output (0-2) (for BACKEND_PS/EPS only) */

	dim_t width_d;     /* desired width of image */

	dim_t height_d;    /* desired height of image */

	double rx;         /* desired x resolution (in dpi) */

	double ry;         /* desired y resolution (in dpi) */

	double sx;         /* desired x scaling factor */

	double sy;         /* desired y scaling factor */

	double stretch;    /* ry/rx, if not otherwise determined */

	dim_t lmar_d, rmar_d, tmar_d, bmar_d;   /* margins */

	double angle;      /* rotate by this many degrees */

	int paperwidth, paperheight;  /* paper size for ps backend (in pt) */

	double unit;       /* granularity of output grid */

	int compress;      /* apply compression? */

	int pslevel;       /* postscript level to use: affects only compression */

	int color;         /* rgb color code 0xrrggbb: line color */

	int fillcolor;     /* rgb color code 0xrrggbb: fill color */

	double gamma;      /* gamma value for pgm backend */

	int longcoding;    /* do not optimize for file size? */

	char *outfile;     /* output filename, if given */

	char **infiles;    /* array of input filenames */

	int infilecount;   /* number of input filenames */

	double blacklevel; /* 0 to 1: black/white cutoff in input file */

	int invert;        /* invert bitmap? */

	int opaque;        /* paint white shapes opaquely? */

	int group;         /* group paths together? */

	int progress;      /* should we display a progress bar? */

};

typedef struct info_s info_t;

extern info_t info;

/* structure to hold per-image information, set e.g. by calc_dimensions */

struct imginfo_s {

	int pixwidth;        /* width of input pixmap */

	int pixheight;       /* height of input pixmap */

	double width;        /* desired width of image (in pt or pixels) */

	double height;       /* desired height of image (in pt or pixels) */

	double lmar, rmar, tmar, bmar;   /* requested margins (in pt) */

	rect_t trans;        /* specify relative position of a tilted rectangle */

};

typedef struct imginfo_s imginfo_t;

double* vectorizarBuffer(const long *cbufferIn, int width, int height, int argc, char *argv[]);

#endif /* POTRACE_RASTER_H */

/* getopt_long and getopt_long_only entry points for GNU getopt.

   Copyright (C) 1987,88,89,90,91,92,93,94,96,97,98

     Free Software Foundation, Inc.

   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or

   modify it under the terms of the GNU Library General Public License as

   published by the Free Software Foundation; either version 2 of the

   License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public

   License along with the GNU C Library; see the file COPYING.LIB.  If not,

   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

   Boston, MA 02111-1307, USA.  */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include "getopt.h"

#if !defined __STDC__ || !__STDC__

/* This is a separate conditional since some stdc systems

   reject `defined (const)'.  */

#ifndef const

#define const

#endif

#endif

#include <stdio.h>

/* Comment out all this code if we are using the GNU C Library, and are not

   actually compiling the library itself.  This code is part of the GNU C

   Library, but also included in many other GNU distributions.  Compiling

   and linking in this code is a waste when using the GNU C library

   (especially if it is a shared library).  Rather than having every GNU

   program understand `configure --with-gnu-libc' and omit the object files,

   it is simpler to just do this in the source for each such file.  */

#define GETOPT_INTERFACE_VERSION 2

#if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2

#include <gnu-versions.h>

#if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION

#define ELIDE_CODE

#endif

#endif

#ifndef ELIDE_CODE

/* This needs to come after some library #include

   to get __GNU_LIBRARY__ defined.  */

#ifdef __GNU_LIBRARY__

#include <stdlib.h>

#endif

#ifndef	NULL

#define NULL 0

#endif

int

getopt_long (argc, argv, options, long_options, opt_index)

     int argc;

     char *const *argv;

     const char *options;

     const struct option *long_options;

     int *opt_index;

{

  return _getopt_internal (argc, argv, options, long_options, opt_index, 0);

}

/* Like getopt_long, but '-' as well as '--' can indicate a long option.

   If an option that starts with '-' (not '--') doesn't match a long option,

   but does match a short option, it is parsed as a short option

   instead.  */

int

getopt_long_only (argc, argv, options, long_options, opt_index)

     int argc;

     char *const *argv;

     const char *options;

     const struct option *long_options;

     int *opt_index;

{

  return _getopt_internal (argc, argv, options, long_options, opt_index, 1);

}

#endif	/* Not ELIDE_CODE.  */

#ifdef TEST

#include <stdio.h>

int

main (argc, argv)

     int argc;

     char **argv;

{

  int c;

  int digit_optind = 0;

  while (1)

    {

      int this_option_optind = optind ? optind : 1;

      int option_index = 0;

      static struct option long_options[] =

      {

	{"add", 1, 0, 0},

	{"append", 0, 0, 0},

	{"delete", 1, 0, 0},

	{"verbose", 0, 0, 0},

	{"create", 0, 0, 0},

	{"file", 1, 0, 0},

	{0, 0, 0, 0}

      };

      c = getopt_long (argc, argv, "abc:d:0123456789",

		       long_options, &option_index);

      if (c == -1)

	break;

      switch (c)

	{

	case 0:

	  printf ("option %s", long_options[option_index].name);

	  if (optarg)

	    printf (" with arg %s", optarg);

	  printf ("\n");

	  break;

	case '0':

	case '1':

	case '2':

	case '3':

	case '4':

	case '5':

	case '6':

	case '7':

	case '8':

	case '9':

	  if (digit_optind != 0 && digit_optind != this_option_optind)

	    printf ("digits occur in two different argv-elements.\n");

	  digit_optind = this_option_optind;

	  printf ("option %c\n", c);

	  break;

	case 'a':

	  printf ("option a\n");

	  break;

	case 'b':

	  printf ("option b\n");

	  break;

	case 'c':

	  printf ("option c with value `%s'\n", optarg);

	  break;

	case 'd':

	  printf ("option d with value `%s'\n", optarg);

	  break;

	case '?':

	  break;

	default:

	  printf ("?? getopt returned character code 0%o ??\n", c);

	}

    }

  if (optind < argc)

    {

      printf ("non-option ARGV-elements: ");

      while (optind < argc)

	printf ("%s ", argv[optind++]);

      printf ("\n");

    }

  exit (0);

}

#endif /* TEST */

/* Copyright (C) 2001-2007 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. */

/* $Id: curve.c 147 2007-04-09 00:44:09Z selinger $ */

/* 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_MALLOC(var, n, typ) \

  if ((var = (typ *)malloc((n)*sizeof(typ))) == NULL) goto malloc_error 

/* ---------------------------------------------------------------------- */

/* allocate and free path objects */

path_t *path_new(void) {

  path_t *p = NULL;

  privpath_t *priv = NULL;

  SAFE_MALLOC(p, 1, path_t);

  memset(p, 0, sizeof(path_t));

  SAFE_MALLOC(priv, 1, privpath_t);

  memset(priv, 0, sizeof(privpath_t));

  p->priv = priv;

  return p;

 malloc_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_MALLOC(curve->tag, n, int);

  SAFE_MALLOC(curve->c, n, dpoint3_t);

  SAFE_MALLOC(curve->vertex, n, dpoint_t);

  SAFE_MALLOC(curve->alpha, n, double);

  SAFE_MALLOC(curve->alpha0, n, double);

  SAFE_MALLOC(curve->beta, n, double);

  return 0;

 malloc_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;

}

/* Copyright (C) 2001-2007 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. */

/* $Id: main.c 147 2007-04-09 00:44:09Z selinger $ */

#include <stdio.h>

#include <stdlib.h>

#include <errno.h>

#include <string.h>

#include <getopt.h>

#include <math.h>

#include "main.h"

#include "potracelib.h"

#include "backend_pdf.h"

#include "backend_eps.h"

#include "backend_pgm.h"

#include "backend_svg.h"

#include "backend_gimp.h"

#include "backend_xfig.h"

#include "potracelib.h"

#include "bitmap_io.h"

#include "bitmap.h"

#include "platform.h"

#include "auxiliary.h"

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#ifndef M_PI

#define M_PI 3.14159265358979323846

#endif

#define UNDEF ((double)(1e30))   /* a value to represent "undefined" */

#define INFTY ((double)(1e30))   /* a value to represent +infinity */

struct info_s info;

#define COL0 "\033[G"  /* reset cursor to column 0 */

/* ---------------------------------------------------------------------- */

/* callback function for progress bar */

struct simple_progress_s {

  char name[22];          /* filename for status bar */

  double dnext;           /* threshold value for next tick */

};

typedef struct simple_progress_s simple_progress_t;

/* print a simple progress bar. This is a callback function that is

   potentially called often; thus, it has been optimized for the

   typical case, which is when the progress bar does not need updating. */

static void simple_progress(double d, void *data) {

  simple_progress_t *p = (simple_progress_t *)data;

  static char b[] = "========================================";

  int tick;    /* number of visible tickmarks, 0..40 */

  int perc;    /* visible percentage, 0..100 */

  /* note: the 0.01 and 0.025 ensure that we always end on 40

     tickmarks and 100%, despite any rounding errors. The 0.995

     ensures that tick always increases when d >= p->dnext. */

  if (d >= p->dnext) {

    tick = (int) floor(d*40+0.01);

    perc = (int) floor(d*100+0.025);

    fprintf(stderr, "%-21s |%-40s| %d%% "COL0"", p->name, b+40-tick, perc);

    p->dnext = (tick+0.995) / 40.0;

  }

}

/* Initialize parameters for simple progress bar. The caller passes an

   allocated simple_progress_t structure to avoid having to malloc it

   here and free it later. */

static inline void init_progress(potrace_progress_t *prog, simple_progress_t *p, const char *filename, int count) {

  const char *q, *s;

  int len;

  /* initialize callback function's data */

  p->dnext = 0;

  if (count != 0) {

    sprintf(p->name, " (p.%d):", count+1);

  } else {

    s = filename;

    if ((q = strrchr(s, '/')) != NULL) {

      s = q+1;

    }

    len = strlen(s);

    strncpy(p->name, s, 21);

    p->name[20] = 0;

    if (len > 20) {

      p->name[17] = '.';

      p->name[18] = '.';

      p->name[19] = '.';

    }

    strcat(p->name, ":");

  }

  /* initialize progress parameters */

  prog->callback = &simple_progress;

  prog->data = (void *)p;

  prog->min = 0.0;

  prog->max = 1.0;

  prog->epsilon = 0.0;

  /* draw first progress bar */

  simple_progress(0.0, prog->data);

  return;

}

/* ---------------------------------------------------------------------- */

/* some data structures for option processing */

struct pageformat_s {

  char *name;

  int w, h;

};

typedef struct pageformat_s pageformat_t;

/* dimensions of the various page formats, in postscript points */

static pageformat_t pageformat[] = {

  { "a4",        595,  842 },

  { "a3",        842, 1191 },

  { "a5",        421,  595 },

  { "b5",        516,  729 },

  { "letter",    612,  792 },

  { "legal",     612, 1008 },

  { "tabloid",   792, 1224 },

  { "statement", 396,  612 },

  { "executive", 540,  720 },

  { "folio",     612,  936 },

  { "quarto",    610,  780 },

  { "10x14",     720, 1008 },

  { NULL, 0, 0 },

};

struct turnpolicy_s {

  char *name;

  int n;

};

typedef struct turnpolicy_s turnpolicy_t;

/* names of turn policies */

static turnpolicy_t turnpolicy[] = {

  {"black",    POTRACE_TURNPOLICY_BLACK},

  {"white",    POTRACE_TURNPOLICY_WHITE},

  {"left",     POTRACE_TURNPOLICY_LEFT},

  {"right",    POTRACE_TURNPOLICY_RIGHT},

  {"minority", POTRACE_TURNPOLICY_MINORITY},

  {"majority", POTRACE_TURNPOLICY_MAJORITY},

  {"random",   POTRACE_TURNPOLICY_RANDOM},

  {NULL, 0},

};

/* backends and their characteristics */

struct backend_s {

  char *name;       /* name of this backend */

  char *ext;        /* file extension */

  int fixed;        /* fixed page size backend? */

  int pixel;        /* pixel-based backend? */

  int multi;        /* multi-page backend? */

  int (*init_f)(FILE *fout);                 /* initialization function */

  int (*page_f)(FILE *fout, potrace_path_t *plist, imginfo_t *imginfo);

                                             /* per-bitmap function */

  int (*term_f)(FILE *fout);                 /* finalization function */

  int opticurve;    /* opticurve capable (true Bezier curves?) */

};

typedef struct backend_s backend_t;  

static backend_t backend[] = {

  {"eps",        ".eps",      0, 0, 0, NULL,    page_eps,   NULL,     1},

  {"postscript", ".ps",       1, 0, 1, init_ps, page_ps,    term_ps,  1},

  {"ps",         ".ps",       1, 0, 1, init_ps, page_ps,    term_ps,  1},

  {"pdf",        ".pdf",      0, 0, 1, init_pdf,page_pdf,   term_pdf, 1},

  {"svg",        ".svg",      0, 0, 0, NULL,    page_svg,   NULL,     1},

  {"pgm",        ".pgm",      0, 1, 1, NULL,    page_pgm,   NULL,     1},

  {"gimppath",   ".gimppath", 0, 1, 0, NULL,    page_gimp,  NULL,     1},

  {"xfig",       ".fig",      1, 0, 0, NULL,    page_xfig,  NULL,     0},

  {NULL, NULL, 0, 0, 0, NULL, NULL, NULL},

};

/* look up a backend by name. If found, return 0 and set *bp. If not

   found leave *bp unchanged and return 1, or 2 on ambiguous

   prefix. */

static int backend_lookup(char *name, backend_t **bp) {

  int i;

  int m=0;  /* prefix matches */

  backend_t *b = NULL;

  for (i=0; backend[i].name; i++) {

    if (strcasecmp(backend[i].name, name)==0) {

      *bp = &backend[i];

      return 0;

    } else if (strncasecmp(backend[i].name, name, strlen(name))==0) {

      m++;

      b = &backend[i];

    }      

  }

  /* if there was no exact match, and exactly one prefix match, use that */

  if (m==1) {  

    *bp = b;

    return 0;

  } else if (m) {

    return 2;

  } else {

    return 1;

  }

}

/* list all available backends by name, in a comma separated list.

   Assume the cursor starts in column j, and break lines at length

   linelen. Do not output any trailing punctuation. Return the column

   the cursor is in. */

static int backend_list(FILE *fout, int j, int linelen) {

  int i;

  for (i=0; backend[i].name; i++) {

    if (j + (int)strlen(backend[i].name) > linelen) {

      fprintf(fout, "\n");

      j = 0;

    }

    j += fprintf(fout, "%s", backend[i].name);

    if (backend[i+1].name) {

      j += fprintf(fout, ", ");

    }

  }

  return j;

}

/* ---------------------------------------------------------------------- */

/* some info functions */

static void license(FILE *f) {

  fprintf(f, 

  "This program is free software; you can redistribute it and/or modify\n"

  "it under the terms of the GNU General Public License as published by\n"

  "the Free Software Foundation; either version 2 of the License, or\n"

  "(at your option) any later version.\n"

  "\n"

  "This program is distributed in the hope that it will be useful,\n"

  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"

  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"

  "GNU General Public License for more details.\n"

  "\n"

  "You should have received a copy of the GNU General Public License\n"

  "along with this program; if not, write to the Free Software\n"

  "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.\n"

	  );

}

static void show_defaults(FILE *f) {

  fprintf(f, "This version of Potrace was compiled with the following defaults:\n");

  fprintf(f, "Default unit: "DEFAULT_DIM_NAME"\n");

  fprintf(f, "Default page size: "DEFAULT_PAPERFORMAT"\n");

}

static void usage(FILE *f) {

  int j;

  fprintf(f, "Usage: "POTRACE" [options] [file...]\n");

  fprintf(f, "General options:\n");

  fprintf(f, " -h, --help                 - print this help message and exit\n");

  fprintf(f, " -v, --version              - print version info and exit\n");

  fprintf(f, " -l, --license              - print license info and exit\n");

  fprintf(f, " -V, --show-defaults        - print compiled-in defaults and exit\n");

  fprintf(f, " --progress                 - show progress bar\n");

  fprintf(f, "Input/output options:\n");

  fprintf(f, " -o, --output <file>        - output to file\n");

  fprintf(f, "Backend selection:\n");

  fprintf(f, " -e, --eps                  - EPS backend (encapsulated postscript) (default)\n");

  fprintf(f, " -p, --postscript           - Postscript backend\n");

  fprintf(f, " -s, --svg                  - SVG backend (scalable vector graphics)\n");

  fprintf(f, " -g, --pgm                  - PGM backend (portable greymap)\n");

  fprintf(f, " -b, --backend <name>       - select backend by name\n");

  fprintf(f, "Algorithm options:\n");

  fprintf(f, " -z, --turnpolicy <policy>  - how to resolve ambiguities in path decomposition\n");

  fprintf(f, " -t, --turdsize <n>         - suppress speckles of up to this size (default 2)\n");

  fprintf(f, " -a, --alphamax <n>         - corner threshold parameter (default 1)\n");

  fprintf(f, " -n, --longcurve            - turn off curve optimization\n");

  fprintf(f, " -O, --opttolerance <n>     - curve optimization tolerance (default 0.2)\n");

  fprintf(f, " -u, --unit <n>             - quantize output to 1/unit pixels (default 10)\n");

  fprintf(f, " -d, --debug <n>            - produce debugging output of type n (n=1,2,3)\n");

  fprintf(f, "Scaling and placement options:\n");

  fprintf(f, " -W, --width <dim>          - width of output image\n");

  fprintf(f, " -H, --height <dim>         - height of output image\n");

  fprintf(f, " -r, --resolution <n>[x<n>] - resolution (in dpi)\n");

  fprintf(f, " -x, --scale <n>[x<n>]      - scaling factor (pgm backend)\n");

  fprintf(f, " -S, --stretch <n>          - yresolution/xresolution\n");

  fprintf(f, " -A, --rotate <angle>       - rotate counterclockwise by angle\n");

  fprintf(f, " -M, --margin <dim>         - margin\n");

  fprintf(f, " -L, --leftmargin <dim>     - left margin\n");

  fprintf(f, " -R, --rightmargin <dim>    - right margin\n");

  fprintf(f, " -T, --topmargin <dim>      - top margin\n");

  fprintf(f, " -B, --bottommargin <dim>   - bottom margin\n");

  fprintf(f, "Output options, supported by some backends:\n");

  fprintf(f, " -C, --color #rrggbb        - set line color (default black)\n");

  fprintf(f, " --fillcolor #rrggbb        - set fill color (default transparent)\n");

  fprintf(f, " --opaque                   - make white shapes opaque\n");

  fprintf(f, " --group                    - group related paths together\n");

  fprintf(f, "Postscript/EPS options:\n");

  fprintf(f, " -P, --pagesize <format>    - page size (default is "DEFAULT_PAPERFORMAT")\n");

  fprintf(f, " -c, --cleartext            - do not compress the output\n");

  fprintf(f, " -2, --level2               - use postscript level 2 compression (default)\n");

#ifdef HAVE_ZLIB

  fprintf(f, " -3, --level3               - use postscript level 3 compression\n");

#endif

  fprintf(f, " -q, --longcoding           - do not optimize for file size\n");

  fprintf(f, "PGM options:\n");

  fprintf(f, " -G, --gamma <n>            - gamma value for anti-aliasing (default 2.2)\n");

  fprintf(f, "Frontend options:\n");

  fprintf(f, " -k, --blacklevel <n>       - black/white cutoff in input file (default 0.5)\n");

  fprintf(f, " -i, --invert               - invert bitmap\n");

  fprintf(f, "\n");

  fprintf(f, "Dimensions can have optional units, e.g. 6.5in, 15cm, 100pt.\n");

  fprintf(f, "Default is "DEFAULT_DIM_NAME" (or pixels for pgm and gimppath backends).\n");

  fprintf(f, "Possible input file formats are: pnm (pbm, pgm, ppm), bmp.\n");

  j = fprintf(f, "Backends are: ");

  backend_list(f, j, 70);

  fprintf(f, ".\n");

}

/* ---------------------------------------------------------------------- */

/* auxiliary functions for parameter parsing */

/* parse a dimension of the kind "1.5in", "7cm", etc. Return result in

   postscript points (=1/72 in). If endptr!=NULL, store pointer to

   next character in *endptr in the manner of strtod(3). */

static dim_t parse_dimension(char *s, char **endptr) {

  char *p;

  dim_t res;

  res.x = strtod(s, &p);

  res.d = 0;

  if (p!=s) {

    if (!strncasecmp(p, "in", 2)) {

      res.d = DIM_IN;

      p += 2;

    } else if (!strncasecmp(p, "cm", 2)) {

      res.d = DIM_CM;

      p += 2;

    } else if (!strncasecmp(p, "mm", 2)) {

      res.d = DIM_MM;

      p += 2;

    } else if (!strncasecmp(p, "pt", 2)) {

      res.d = DIM_PT;

      p += 2;

    }

  }

  if (endptr!=NULL) {

    *endptr = p;

  }

  return res;

}

/* parse a pair of dimensions, such as "8.5x11in", "30mmx4cm" */

static void parse_dimensions(char *s, char **endptr, dim_t *dxp, dim_t *dyp) {

  char *p, *q;

  dim_t dx, dy;

  dx = parse_dimension(s, &p);

  if (p==s) {

    goto fail;

  }

  if (*p != 'x') {

    goto fail;

  }

  p++;

  dy = parse_dimension(p, &q);

  if (q==p) {

    goto fail;

  }

  if (dx.d && !dy.d) {

    dy.d = dx.d;

  } else if (!dx.d && dy.d) {

    dx.d = dy.d;

  }

  *dxp = dx;

  *dyp = dy;

  if (endptr != NULL) {

    *endptr = q;

  }

  return;

 fail:

  dx.x = dx.d = dy.x = dy.d = 0;

  *dxp = dx;

  *dyp = dy;

  if (endptr != NULL) {

    *endptr = s;

  }

  return;

}

static inline double double_of_dim(dim_t d, double def) {

  if (d.d) {

    return d.x * d.d;

  } else {

    return d.x * def;

  }

}

static int parse_color(char *s) {

  int i, d;

  int col = 0;

  if (s[0] != '#' || strlen(s) != 7) {

    return -1;

  }

  for (i=0; i<6; i++) {

    d = s[6-i];

    if (d >= '0' && d <= '9') {

      col |= (d-'0') << (4*i);

    } else if (d >= 'a' && d <= 'f') {

      col |= (d-'a'+10) << (4*i);

    } else if (d >= 'A' && d <= 'F') {

      col |= (d-'A'+10) << (4*i);

    } else {

      return -1;

    }

  }

  return col;

}  

/* ---------------------------------------------------------------------- */

/* option processing */

/* codes for options that don't have short form */

#define OPT_GROUP     300

#define OPT_OPAQUE    301

#define OPT_FILLCOLOR 302

#define OPT_PROGRESS  303

static struct option longopts[] = {

  {"help",          0, 0, 'h'},

  {"version",       0, 0, 'v'},

  {"license",       0, 0, 'l'},

  {"show-defaults", 0, 0, 'V'},

  {"progress",      0, 0, OPT_PROGRESS},

  {"width",         1, 0, 'W'},

  {"height",        1, 0, 'H'},

  {"resolution",    1, 0, 'r'},

  {"scale",         1, 0, 'x'},

  {"stretch",       1, 0, 'S'},

  {"margin",        1, 0, 'M'},

  {"leftmargin",    1, 0, 'L'},

  {"rightmargin",   1, 0, 'R'},

  {"topmargin",     1, 0, 'T'},

  {"bottommargin",  1, 0, 'B'},

  {"rotate",        1, 0, 'A'},

  {"pagesize",      1, 0, 'P'},

  {"turdsize",      1, 0, 't'},

  {"unit",          1, 0, 'u'},

  {"cleartext",     0, 0, 'c'},

  {"level2",        0, 0, '2'},

  {"level3",        0, 0, '3'},

  {"eps",           0, 0, 'e'},

  {"postscript",    0, 0, 'p'},

  {"svg",           0, 0, 's'},

  {"pgm",           0, 0, 'g'},

  {"backend",       1, 0, 'b'},

  {"debug",         1, 0, 'd'},

  {"color",         1, 0, 'C'},

  {"fillcolor",     1, 0, OPT_FILLCOLOR},

  {"turnpolicy",    1, 0, 'z'},

  {"gamma",         1, 0, 'G'},

  {"longcurve",     0, 0, 'n'},

  {"longcoding",    0, 0, 'q'},

  {"alphamax",      1, 0, 'a'},

  {"opttolerance",  1, 0, 'O'},

  {"output",        1, 0, 'o'},

  {"blacklevel",    1, 0, 'k'},

  {"invert",        0, 0, 'i'},

  {"opaque",        0, 0, OPT_OPAQUE},

  {"group",         0, 0, OPT_GROUP},

  {0, 0, 0, 0}

};

static char *shortopts = "hvlVW:H:r:x:S:M:L:R:T:B:A:P:t:u:c23epsgb:d:C:z:G:nqa:O:o:k:i";

static void dopts(int ac, char *av[]) {

  int c;

  char *p;

  int i, j, r;

  dim_t dim, dimx, dimy;

  int matches, bestmatch;

  /* defaults */

  backend_lookup("eps", &info.backend);

  info.debug = 0;

  info.width_d.x = UNDEF;

  info.height_d.x = UNDEF;

  info.rx = UNDEF;

  info.ry = UNDEF;

  info.sx = UNDEF;

  info.sy = UNDEF;

  info.stretch = 1;

  info.lmar_d.x = UNDEF;

  info.rmar_d.x = UNDEF;

  info.tmar_d.x = UNDEF;

  info.bmar_d.x = UNDEF;

  info.angle = 0;

  info.paperwidth = DEFAULT_PAPERWIDTH;

  info.paperheight = DEFAULT_PAPERHEIGHT;

  info.unit = 10;

  info.compress = 1;

  info.pslevel = 2;

  info.color = 0x000000;

  info.gamma = 2.2;

  info.param = potrace_param_default();

  if (!info.param) {

    fprintf(stderr, ""POTRACE": %s\n", strerror(errno));

    exit(1);

  }

  info.longcoding = 0;

  info.outfile = NULL;

  info.blacklevel = 0.5;

  info.invert = 0;

  info.opaque = 0;

  info.group = 0;

  info.fillcolor = 0xffffff;

  info.progress = 0;

  while ((c = getopt_long(ac, av, shortopts, longopts, NULL)) != -1) {

    switch (c) {

    case 'h':

      fprintf(stdout, ""POTRACE" "VERSION". Transforms bitmaps into vector graphics.\n\n");

      usage(stdout);

      exit(0);

      break;

    case 'v':

      fprintf(stdout, ""POTRACE" "VERSION". Copyright (C) 2001-2007 Peter Selinger.\n");

      fprintf(stdout, "Library version: %s\n", potrace_version());

      exit(0);

      break;

    case 'l':

      fprintf(stdout, ""POTRACE" "VERSION". Copyright (C) 2001-2007 Peter Selinger.\n\n");

      license(stdout);

      exit(0);

      break;

    case 'V':

      fprintf(stdout, ""POTRACE" "VERSION". Copyright (C) 2001-2007 Peter Selinger.\n");

      show_defaults(stdout);

      exit(0);

      break;

    case OPT_PROGRESS:

      info.progress = 1;

      break;

    case 'W':

      info.width_d = parse_dimension(optarg, &p);

      if (*p) {

	fprintf(stderr, ""POTRACE": invalid dimension -- %s\n", optarg);

	exit(1);

      }

      break;

    case 'H':

      info.height_d = parse_dimension(optarg, &p);

      if (*p) {

	fprintf(stderr, ""POTRACE": invalid dimension -- %s\n", optarg);

	exit(1);

      }

      break;

    case 'r':

      parse_dimensions(optarg, &p, &dimx, &dimy);

      if (*p == 0 && dimx.d == 0 && dimy.d == 0) {

	info.rx = dimx.x;

	info.ry = dimy.x;

	break;

      }

      dim = parse_dimension(optarg, &p);

      if (*p == 0 && dim.d == 0) {

	info.rx = info.ry = dim.x;

	break;

      }

      fprintf(stderr, ""POTRACE": invalid resolution -- %s\n", optarg);

      exit(1);

      break;

    case 'x':

      parse_dimensions(optarg, &p, &dimx, &dimy);

      if (*p == 0 && dimx.d == 0 && dimy.d == 0) {

	info.sx = dimx.x;

	info.sy = dimy.x;

	break;

      }

      dim = parse_dimension(optarg, &p);

      if (*p == 0 && dim.d == 0) {

	info.sx = info.sy = dim.x;

	break;

      }

      fprintf(stderr, ""POTRACE": invalid scaling factor -- %s\n", optarg);

      exit(1);

      break;

    case 'S':

      info.stretch = atof(optarg);

      break;

    case 'M':

      info.lmar_d = parse_dimension(optarg, &p);

      if (*p) {

	fprintf(stderr, ""POTRACE": invalid dimension -- %s\n", optarg);

	exit(1);

      }

      info.rmar_d = info.tmar_d = info.bmar_d = info.lmar_d;

      break;

    case 'L':

      info.lmar_d = parse_dimension(optarg, &p);

      if (*p) {

	fprintf(stderr, ""POTRACE": invalid dimension -- %s\n", optarg);

	exit(1);

      }

      break;

    case 'R':

      info.rmar_d = parse_dimension(optarg, &p);

      if (*p) {

	fprintf(stderr, ""POTRACE": invalid dimension -- %s\n", optarg);

	exit(1);

      }

      break;

    case 'T':

      info.tmar_d = parse_dimension(optarg, &p);

      if (*p) {

	fprintf(stderr, ""POTRACE": invalid dimension -- %s\n", optarg);

	exit(1);

      }

      break;

    case 'B':

      info.bmar_d = parse_dimension(optarg, &p);

      if (*p) {

	fprintf(stderr, ""POTRACE": invalid dimension -- %s\n", optarg);

	exit(1);

      }

      break;

    case 'A':

      info.angle = strtod(optarg, &p);

      if (*p) {

	fprintf(stderr, ""POTRACE": invalid angle -- %s\n", optarg);

	exit(1);

      }

      break;

    case 'P':

      matches = 0;

      bestmatch = 0;

      for (i=0; pageformat[i].name!=NULL; i++) {

        if (strcasecmp(pageformat[i].name, optarg)==0) {

          matches = 1;

          bestmatch = i;

          break;

	} else if (strncasecmp(pageformat[i].name, optarg, strlen(optarg))==0) {

	  /* don't allow partial match on "10x14" */

	  if (optarg[0] != '1') {

	    matches++;

	    bestmatch = i;

	  }

	}

      }

      if (matches == 1) {

	info.paperwidth = pageformat[bestmatch].w;

	info.paperheight = pageformat[bestmatch].h;

	break;

      }

      parse_dimensions(optarg, &p, &dimx, &dimy);

      if (*p == 0) {

	info.paperwidth = (int)rint(double_of_dim(dimx, DEFAULT_DIM));

	info.paperheight = (int)rint(double_of_dim(dimy, DEFAULT_DIM));

	break;

      }

      if (matches == 0) {

	fprintf(stderr, ""POTRACE": unrecognized page format -- %s\n", optarg);

      } else {

	fprintf(stderr, ""POTRACE": ambiguous page format -- %s\n", optarg);

      }

      j = fprintf(stderr, "Use one of: ");

      for (i=0; pageformat[i].name!=NULL; i++) {

	if (j + strlen(pageformat[i].name) > 75) {

	  fprintf(stderr, "\n");

	  j = 0;

	}

	j += fprintf(stderr, "%s, ", pageformat[i].name);

      }

      fprintf(stderr, "or specify <dim>x<dim>.\n");

      exit(1);

      break;

    case 't':

      info.param->turdsize = atoi(optarg);

      break;

    case 'u':

      info.unit = strtod(optarg, &p);

      if (*p) {

        fprintf(stderr, ""POTRACE": invalid unit -- %s\n", optarg);

        exit(1);

      }

      break;

    case 'c':

      info.pslevel = 2;

      info.compress = 0;

      break;

    case '2':

      info.pslevel = 2;

      info.compress = 1;

      break;

    case '3':

#ifdef HAVE_ZLIB

      info.pslevel = 3;

      info.compress = 1;

#else

      fprintf(stderr, ""POTRACE": option -3 not supported, using -2 instead.\n");

      info.pslevel = 2;

      info.compress = 1;

#endif

      break;

    case 'e':

      backend_lookup("eps", &info.backend);

      break;

    case 'p':

      backend_lookup("postscript", &info.backend);

      break;

    case 's':

      backend_lookup("svg", &info.backend);

      break;

    case 'g':

      backend_lookup("pgm", &info.backend);

      break;

    case 'b':

      r = backend_lookup(optarg, &info.backend);

      if (r==1 || r==2) {

	if (r==1) {

	  fprintf(stderr, ""POTRACE": unrecognized backend -- %s\n", optarg);

	} else {

	  fprintf(stderr, ""POTRACE": ambiguous backend -- %s\n", optarg);

	}

	j = fprintf(stderr, "Use one of: ");

	backend_list(stderr, j, 70);

	fprintf(stderr, ".\n");

	exit(1);

      }

      break;

    case 'd':

      info.debug = atoi(optarg);

      break;

    case 'C':

      info.color = parse_color(optarg);

      if (info.color == -1) {

	fprintf(stderr, ""POTRACE": invalid color -- %s\n", optarg);

	exit(1);

      }

      break;

    case OPT_FILLCOLOR:

      info.fillcolor = parse_color(optarg);

      if (info.fillcolor == -1) {

	fprintf(stderr, ""POTRACE": invalid color -- %s\n", optarg);

	exit(1);

      }

      info.opaque = 1;

      break;

    case 'z':

      matches = 0;

      bestmatch = 0;

      for (i=0; turnpolicy[i].name!=NULL; i++) {

        if (strcasecmp(turnpolicy[i].name, optarg)==0) {

	  matches = 1;

	  bestmatch = i;

          break;

	} else if (strncasecmp(turnpolicy[i].name, optarg, strlen(optarg))==0) {

	  matches++;

	  bestmatch = i;

	}

      }

      if (matches == 1) {

	info.param->turnpolicy = turnpolicy[bestmatch].n;

	break;

      }

      if (matches == 0) {

	fprintf(stderr, ""POTRACE": unrecognized turnpolicy -- %s\n", optarg);

      } else {

	fprintf(stderr, ""POTRACE": ambiguous turnpolicy -- %s\n", optarg);

      }

      j = fprintf(stderr, "Use one of: ");

      for (i=0; turnpolicy[i].name!=NULL; i++) {

	if (j + strlen(turnpolicy[i].name) > 75) {

	  fprintf(stderr, "\n");

	  j = 0;

	}

	j += fprintf(stderr, "%s%s", turnpolicy[i].name, turnpolicy[i+1].name ? ", " : "");

      }

      fprintf(stderr, ".\n");

      exit(1);

      break;

    case 'G':

      info.gamma = atof(optarg);

      break;

    case 'n':

      info.param->opticurve = 0;

      break;

    case 'q':

      info.longcoding = 1;

      break;

    case 'a':

      info.param->alphamax = strtod(optarg, &p);

      if (*p) {

	fprintf(stderr, ""POTRACE": invalid alphamax -- %s\n", optarg);

	exit(1);

      }

      break;

    case 'O':

      info.param->opttolerance = strtod(optarg, &p);

      if (*p) {

	fprintf(stderr, ""POTRACE": invalid opttolerance -- %s\n", optarg);

	exit(1);

      }

      break;

    case 'o':

      free(info.outfile);

      info.outfile = strdup(optarg);

      break;

    case 'k':

      info.blacklevel = strtod(optarg, &p);

      if (*p) {

	fprintf(stderr, ""POTRACE": invalid blacklevel -- %s\n", optarg);

	exit(1);

      }

      break;

    case 'i':

      info.invert = 1;

      break;

    case OPT_OPAQUE:

      info.opaque = 1;

      break;

    case OPT_GROUP:

      info.group = 1;

      break;

    case '?':

      fprintf(stderr, "Try --help for more info\n");

      exit(1);

      break;

    default:

      fprintf(stderr, ""POTRACE": Unimplemented option -- %c\n", c);

      exit(1);

    }

  }

  info.infiles = &av[optind];