Application: gvSIG desktop

<?xml version="1.0" encoding="UTF-8"?>

<projectDescription>

	<name>libjni-potrace</name>

	<comment></comment>

	<projects>

	</projects>

	<buildSpec>

		<buildCommand>

			<name>org.eclipse.jdt.core.javabuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

	</buildSpec>

	<natures>

		<nature>org.eclipse.jdt.core.javanature</nature>

	</natures>

</projectDescription>

/* 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: backend_pdf.c 147 2007-04-09 00:44:09Z selinger $ */

/* The PDF backend of Potrace. Stream compression is optionally

	supplied via the functions in flate.c. */

#include <stdio.h>

#include <stdarg.h>

#include <string.h>

#include <math.h>

#include <stdlib.h>

#include "main.h"

#include "backend_pdf.h"

#include "flate.h"

#include "lists.h"

#include "potracelib.h"

#include "auxiliary.h"

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#ifndef M_PI

	#define M_PI 3.14159265358979323846

#endif

typedef int color_t;

#define black  0x000000

#define red    0xff0000

#define green  0x008000

#define blue   0x0000ff

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

/* auxiliary: growing arrays */

struct intarray_s {

  int size;

  int *data;

};

typedef struct intarray_s intarray_t;

static inline void intarray_init(intarray_t *ar) {

  ar->size = 0;

  ar->data = NULL;

}

static inline void intarray_term(intarray_t *ar) {

  free(ar->data);

  ar->size = 0;

  ar->data = NULL;

}

/* Set ar[n]=val. Expects n>=0. Grows array if necessary. Return 0 on

   success and -1 on error with errno set. */

static inline int intarray_set(intarray_t *ar, int n, int val) {

  int *p;

  int s;

  if (n >= ar->size) {

    s = n+1024;

    p = (int *)realloc(ar->data, s * sizeof(int));

    if (!p) {

      return -1;

    }

    ar->data = p;

    ar->size = s;

  }

  ar->data[n] = val;

  return 0;

}

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

/* some global variables */

static intarray_t xref;

static int nxref = 0;

static intarray_t pages;

static int npages;

static int streamofs;

static size_t outcount;  /* output file position */

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

/* functions for interfacing with compression backend */

/* xship: callback function that must be initialized before calling

   any other functions of the "ship" family. xship_file must be

   initialized too. */

/* print the token to f, but filtered through a compression

   filter in case filter!=0 */

static int (*xship)(FILE *f, int filter, char *s, int len);

static FILE *xship_file;

/* ship PDF code, filtered */

static int ship(const char *fmt, ...) {

  va_list args;

  static char buf[4096]; /* static string limit is okay here because

			    we only use constant format strings - for

			    the same reason, it is okay to use

			    vsprintf instead of vsnprintf below. */

  va_start(args, fmt);

  vsprintf(buf, fmt, args);

  buf[4095] = 0;

  va_end(args);

  outcount += xship(xship_file, 1, buf, strlen(buf));

  return 0;

}  

/* ship PDF code, unfiltered */

static int shipclear(char *fmt, ...) {

  static char buf[4096];

  va_list args;

  va_start(args, fmt);

  vsprintf(buf, fmt, args);

  buf[4095] = 0;

  va_end(args);

  outcount += xship(xship_file, 0, buf, strlen(buf));

  return 0;

}

/* set all callback functions */

static void pdf_callbacks(FILE *fout) {

  if (info.compress) {

    xship = pdf_xship;

  } else {

    xship = dummy_xship;

  }

  xship_file = fout;

}  

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

/* PDF path-drawing auxiliary functions */

/* coordinate quantization */

static inline point_t unit(dpoint_t p) {

  point_t q;

  q.x = (long)(floor(p.x*info.unit+.5));

  q.y = (long)(floor(p.y*info.unit+.5));

  return q;

}

static void pdf_coords(dpoint_t p) {

  point_t cur = unit(p);

  ship("%ld %ld ", cur.x, cur.y);

}

static void pdf_moveto(dpoint_t p) {

  pdf_coords(p);

  ship("m\n");

}

static void pdf_lineto(dpoint_t p) {

  pdf_coords(p);

  ship("l\n");

}

static void pdf_curveto(dpoint_t p1, dpoint_t p2, dpoint_t p3) {

  point_t q1, q2, q3;

  q1 = unit(p1);

  q2 = unit(p2);

  q3 = unit(p3);

  ship("%ld %ld %ld %ld %ld %ld c\n", q1.x, q1.y, q2.x, q2.y, q3.x, q3.y);

}

/* this procedure returns a statically allocated string */

static char *pdf_colorstring(const color_t col) {

  double r, g, b;

  static char buf[100];

  r = (col & 0xff0000) >> 16;

  g = (col & 0x00ff00) >> 8;

  b = (col & 0x0000ff) >> 0;

  if (r==0 && g==0 && b==0) {

    return "0 g";

  } else if (r==255 && g==255 && b==255) {

    return "1 g";

  } else if (r == g && g == b) {

    sprintf(buf, "%.3f g", r/255.0);

    return buf;

  } else {

    sprintf(buf, "%.3f %.3f %.3f rg", r/255.0, g/255.0, b/255.0);

    return buf;

  }

}

static color_t pdf_color = -1;

static double pdf_width = -1;

static void pdf_setcolor(const color_t col) {

  if (col == pdf_color) {

    return;

  }

  pdf_color = col;

  ship("%s\n", pdf_colorstring(col));

}

/* explicit encoding, does not use special macros */

static int pdf_path(potrace_curve_t *curve) {

  int i;

  dpoint_t *c;

  int m = curve->n;

  c = curve->c[m-1];

  pdf_moveto(c[2]);

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

    c = curve->c[i];

    switch (curve->tag[i]) {

    case POTRACE_CORNER:

      pdf_lineto(c[1]);

      pdf_lineto(c[2]);

      break;

    case POTRACE_CURVETO:

      pdf_curveto(c[0], c[1], c[2]);

      break;

    }

  }

  return 0;

}

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

/* Backends for various types of output. */

/* Normal output: black on transparent */

static int render0(potrace_path_t *plist) {

  potrace_path_t *p;

  pdf_setcolor(info.color);

  list_forall (p, plist) {

    pdf_path(&p->curve);

    ship("h\n");

    if (p->next == NULL || p->next->sign == '+') {

      ship("f\n");

    }

  }

  return 0;

}

/* Opaque output: alternating black and white */

static int render0_opaque(potrace_path_t *plist) {

  potrace_path_t *p;

  list_forall (p, plist) {

    pdf_path(&p->curve);

    ship("h\n");

    pdf_setcolor(p->sign=='+' ? info.color : info.fillcolor);

    ship("f\n");

  }

  return 0;

}

/* select the appropriate rendering function from above */

static int pdf_render(potrace_path_t *plist)

{

  if (info.opaque) {

    return render0_opaque(plist);

  }

  return render0(plist);

}  

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

/* PDF header and footer */

int init_pdf(FILE *fout)

{

        intarray_init(&xref);

	intarray_init(&pages);

	nxref = 0;

	npages = 0;

	/* set callback functions for shipping routines */

	pdf_callbacks(fout);

	outcount = 0;

	shipclear("%%PDF-1.3\n");

	intarray_set(&xref, nxref++, outcount);

	shipclear("1 0 obj\n<</Type/Catalog/Pages 3 0 R>>\nendobj\n");

	intarray_set(&xref, nxref++, outcount);

	shipclear("2 0 obj\n"

		"<</Creator"

		"("POTRACE" "VERSION", written by Peter Selinger 2001-2007)>>\n"

		"endobj\n");

	/* delay obj #3 (pages) until end */

	nxref++;

	fflush(fout);

	return 0;

}

int term_pdf(FILE *fout)

{

	int startxref;

	int i;

	pdf_callbacks(fout);

	intarray_set(&xref, 2, outcount);

	shipclear("3 0 obj\n"

		"<</Type/Pages/Count %d/Kids[\n", npages);

	for (i = 0; i < npages; i++)

		shipclear("%d 0 R\n", pages.data[i]);

	shipclear("]>>\nendobj\n");

	startxref = outcount;

	shipclear("xref\n0 %d\n", nxref + 1);

	shipclear("0000000000 65535 f \n");

	for (i = 0; i < nxref; i++)

		shipclear("%0.10d 00000 n \n", xref.data[i]);

	shipclear("trailer\n<</Size %d/Root 1 0 R/Info 2 0 R>>\n", nxref + 1);

	shipclear("startxref\n%d\n%%%%EOF\n", startxref);

	fflush(fout);

	intarray_term(&xref);

	intarray_term(&pages);

	return 0;

}

static void pdf_pageinit(imginfo_t *imginfo)

{

	double s, c;

	double origx = imginfo->trans.orig[0] + imginfo->lmar;

	double origy = imginfo->trans.orig[1] + imginfo->bmar;

	double scalex = imginfo->width / imginfo->pixwidth / info.unit;

	double scaley = imginfo->height / imginfo->pixheight / info.unit;

	int pagew = (int)ceil(imginfo->trans.bb[0]+imginfo->lmar+imginfo->rmar);

	int pageh = (int)ceil(imginfo->trans.bb[1]+imginfo->tmar+imginfo->bmar);

	pdf_color = -1;

	pdf_width = -1;

	intarray_set(&xref, nxref++, outcount);

	shipclear("%d 0 obj\n", nxref);

	shipclear("<</Type/Page/Parent 3 0 R/Resources<</ProcSet[/PDF]>>");

	shipclear("/MediaBox[0 0 %d %d]", pagew, pageh);

	shipclear("/Contents %d 0 R>>\n", nxref + 1);

	shipclear("endobj\n");

	intarray_set(&pages, npages++, nxref);

	intarray_set(&xref, nxref++, outcount);

	shipclear("%d 0 obj\n", nxref);

	if (info.compress)

		shipclear("<</Filter/FlateDecode/Length %d 0 R>>\n", nxref + 1);

	else

		shipclear("<</Length %d 0 R>>\n", nxref + 1);

	shipclear("stream\n");

	streamofs = outcount;

	s = sin(info.angle * M_PI / 180.0);

	c = cos(info.angle * M_PI / 180.0);

	ship("%f %f %f %f %.0f %.0f cm\n", scalex*c, scalex*s, -scaley*s, scaley*c, origx, origy);

}

static void pdf_pageterm(void)

{

	int streamlen;

	shipclear("");

	streamlen = outcount - streamofs;

	shipclear("endstream\nendobj\n");

	intarray_set(&xref, nxref++, outcount);

	shipclear("%d 0 obj\n%d\nendobj\n", nxref, streamlen);

}

int page_pdf(FILE *fout, potrace_path_t *plist, imginfo_t *imginfo)

{

  int r;

  pdf_callbacks(fout);

  pdf_pageinit(imginfo);

  r = pdf_render(plist);

  if (r) {

    return r;

  }

  pdf_pageterm();

  fflush(fout);

  return 0;

}

/* 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. */

#include <stdlib.h>

#include <string.h>

#include "potracelib.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). 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) {

  return "potracelib "VERSION"";

}

/* 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: backend_pdf.h 147 2007-04-09 00:44:09Z selinger $ */

#ifndef BACKEND_PDF_H

#define BACKEND_PDF_H

#include "potracelib.h"

#include "main.h"

int init_pdf(FILE *fout);

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

int term_pdf(FILE *fout);

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

#endif /* BACKEND_PDF_H */

/* 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. */

/* A simple and self-contained demo of the potracelib API */

#include <stdio.h>

#include <string.h>

#include <errno.h>

#include <stdlib.h>

#include "potracelib.h"

#define WIDTH 250

#define HEIGHT 250

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

/* auxiliary bitmap functions */

/* macros for writing individual bitmap pixels */

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

#define BM_WORDBITS (8*BM_WORDSIZE)

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

#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_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_UPUT(bm, x, y, b) ((b) ? BM_USET(bm, x, y) : BM_UCLR(bm, x, y))

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

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

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

}

/* free a bitmap */

static void bm_free(potrace_bitmap_t *bm) {

  if (bm != NULL) {

    free(bm->map);

  }

  free(bm);

}

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

/* demo */

int main() {

  int x, y, i;

  potrace_bitmap_t *bm;

  potrace_param_t *param;

  potrace_path_t *p;

  potrace_state_t *st;

  int n, *tag;

  potrace_dpoint_t (*c)[3];

  /* create a bitmap */

  bm = bm_new(WIDTH, HEIGHT);

  if (!bm) {

    fprintf(stderr, "Error allocating bitmap: %s\n", strerror(errno)); 

    return 1;

  }

  /* fill the bitmap with some pattern */

  for (y=0; y<HEIGHT; y++) {

    for (x=0; x<WIDTH; x++) {

      BM_PUT(bm, x, y, ((x*x + y*y*y) % 10000 < 5000) ? 1 : 0);

    }

  }

  /* set tracing parameters, starting from defaults */

  param = potrace_param_default();

  if (!param) {

    fprintf(stderr, "Error allocating parameters: %s\n", strerror(errno)); 

    return 1;

  }

  param->turdsize = 0;

  /* trace the bitmap */

  st = potrace_trace(param, bm);

  if (!st || st->status != POTRACE_STATUS_OK) {

    fprintf(stderr, "Error tracing bitmap: %s\n", strerror(errno));

    return 1;

  }

  bm_free(bm);

  /* output vector data, e.g. as a rudimentary EPS file */

  printf("%%!PS-Adobe-3.0 EPSF-3.0\n");

  printf("%%%%BoundingBox: 0 0 %d %d\n", WIDTH, HEIGHT);

  printf("gsave\n");

  /* draw each curve */

  p = st->plist;

  while (p != NULL) {

    n = p->curve.n;

    tag = p->curve.tag;

    c = p->curve.c;

    printf("%f %f moveto\n", c[n-1][2].x, c[n-1][2].y);

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

      switch (tag[i]) {

      case POTRACE_CORNER:

	printf("%f %f lineto\n", c[i][1].x, c[i][1].y);

	printf("%f %f lineto\n", c[i][2].x, c[i][2].y);

	break;

      case POTRACE_CURVETO:

	printf("%f %f %f %f %f %f curveto\n", 

	       c[i][0].x, c[i][0].y,

	       c[i][1].x, c[i][1].y,

	       c[i][2].x, c[i][2].y);

	break;

      }

    }

    /* at the end of a group of a positive path and its negative

       children, fill. */

    if (p->next == NULL || p->next->sign == '+') {

      printf("0 setgray fill\n");

    }

    p = p->next;

  }

  printf("grestore\n");

  printf("%%EOF\n");

  potrace_state_free(st);

  potrace_param_free(param);

  return 0;

}

/* 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 POTRACELIB_H

#define POTRACELIB_H

/* this file defines the API for the core Potrace library. For a more

   detailed description of the API, see doc/potracelib.txt */

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

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

#endif /* POTRACELIB_H */

/* 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. */

/* this header file contains some platform dependent stuff */

#ifndef PLATFORM_H

#define PLATFORM_H

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

/* in Windows, set all file i/o to binary */

#ifdef __MINGW32__

#include <fcntl.h>

unsigned int _CRT_fmode = _O_BINARY;

#endif

#ifdef __CYGWIN__

#include <fcntl.h>

#include <io.h>

static inline void platform_init(void) {

  setmode(0,O_BINARY); 

  setmode(1,O_BINARY);

}

#else

static inline void platform_init(void) {

  /* NOP */

}

#endif

#endif /* PLATFORM_H */

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

/* 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: flate.c 147 2007-04-09 00:44:09Z selinger $ */

/* the PostScript compression module of Potrace. The basic interface

   is through the *_xship function, which processes a byte array and

   outputs it in compressed or verbatim form, depending on whether

   filter is 1 or 0. To flush the output, simply call with the empty

   string and filter=0. filter=2 is used to output encoded text but

   without the PostScript header to turn on the encoding. Each

   function has variants for shipping a single character, a

   null-terminated string, or a byte array. */

/* different compression algorithms are available. There is

   dummy_xship, which is just the identity, and flate_xship, which

   uses zlib compression. Also, lzw_xship provides LZW compression

   from the file lzw.c/h. a85_xship provides a85-encoding without

   compression. Each function returns the actual number of characters

   written. */

/* note: the functions provided here have global state and are not

   reentrant */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <errno.h>

#ifdef HAVE_ZLIB

#include <zlib.h>

#endif

#include "flate.h"

#include "lzw.h"

#define OUTSIZE 1000

static int a85init(FILE *f);

static int a85finish(FILE *f);

static int a85write(FILE *f, char *buf, int n);

static int a85out(FILE *f, int n);

static int a85spool(FILE *f, char c);

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

/* dummy interface: no encoding */

int dummy_xship(FILE *f, int filter, char *s, int len) {

  fwrite(s, 1, len, f);

  return len;

}

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

/* flate interface: zlib (=postscript level 3) compression and a85 */

#ifdef HAVE_ZLIB

int pdf_xship(FILE *f, int filter, char *s, int len) {

	static int fstate = 0;

	static z_stream c_stream;

	char outbuf[OUTSIZE];

	int err;

	int n=0;

  if (filter && !fstate) {

    /* switch on filtering */

    c_stream.zalloc = Z_NULL;

    c_stream.zfree = Z_NULL;

    c_stream.opaque = Z_NULL;

    err = deflateInit(&c_stream, 9);

    if (err != Z_OK) {

      fprintf(stderr, "deflateInit: %s (%d)\n", c_stream.msg, err);

      exit(1);

    }

    c_stream.avail_in = 0;

    fstate = 1;

  } else if (!filter && fstate) {

    /* switch off filtering */

    /* flush stream */

    do {

      c_stream.next_out = (Bytef*)outbuf;

      c_stream.avail_out = OUTSIZE;

      err = deflate(&c_stream, Z_FINISH);

      if (err != Z_OK && err != Z_STREAM_END) {

	fprintf(stderr, "deflate: %s (%d)\n", c_stream.msg, err);

	exit(1);

      }

      n += fwrite(outbuf, 1, OUTSIZE-c_stream.avail_out, f);

    } while (err != Z_STREAM_END);

    fstate = 0;

  }

  if (!fstate) {

    fwrite(s, 1, len, f);

    return n+len;

  }

  /* do the actual compression */

  c_stream.next_in = (Bytef*) s;

  c_stream.avail_in = len;

  do {

    c_stream.next_out = (Bytef*) outbuf;

    c_stream.avail_out = OUTSIZE;

    err = deflate(&c_stream, Z_NO_FLUSH);

    if (err != Z_OK) {

      fprintf(stderr, "deflate: %s (%d)\n", c_stream.msg, err);

      exit(1);

    }

    n += fwrite(outbuf, 1, OUTSIZE-c_stream.avail_out, f);

  } while (!c_stream.avail_out);

  return n;

}

/* ship len bytes from s using zlib compression. */

int flate_xship(FILE *f, int filter, char *s, int len) {

  static int fstate = 0;

  static z_stream c_stream;

  char outbuf[OUTSIZE];

  int err;

  int n=0;

  if (filter && !fstate) {

    /* switch on filtering */

    if (filter == 1) {

      n += fprintf(f, "currentfile /ASCII85Decode filter /FlateDecode filter cvx exec\n");

    }

    c_stream.zalloc = Z_NULL;

    c_stream.zfree = Z_NULL;

    c_stream.opaque = Z_NULL;

    err = deflateInit(&c_stream, 9);

    if (err != Z_OK) {

      fprintf(stderr, "deflateInit: %s (%d)\n", c_stream.msg, err);

      exit(1);

    }

    c_stream.avail_in = 0;

    n += a85init(f);

    fstate = 1;

  } else if (!filter && fstate) {

    /* switch off filtering */

    /* flush stream */

    do {

      c_stream.next_out = (Bytef*)outbuf;

      c_stream.avail_out = OUTSIZE;

      err = deflate(&c_stream, Z_FINISH);

      if (err != Z_OK && err != Z_STREAM_END) {

	fprintf(stderr, "deflate: %s (%d)\n", c_stream.msg, err);

	exit(1);

      }

      n += a85write(f, outbuf, OUTSIZE-c_stream.avail_out);

    } while (err != Z_STREAM_END);

    n += a85finish(f);

    fstate = 0;

  }

  if (!fstate) {

    fwrite(s, 1, len, f);

    return n+len;

  }

  /* do the actual compression */

  c_stream.next_in = (Bytef*) s;

  c_stream.avail_in = len;

  do {

    c_stream.next_out = (Bytef*) outbuf;

    c_stream.avail_out = OUTSIZE;

    err = deflate(&c_stream, Z_NO_FLUSH);

    if (err != Z_OK) {

      fprintf(stderr, "deflate: %s (%d)\n", c_stream.msg, err);

      exit(1);

    }

    n += a85write(f, outbuf, OUTSIZE-c_stream.avail_out);

  } while (!c_stream.avail_out);

  return n;

}

#else  /* HAVE_ZLIB */

int pdf_xship(FILE *f, int filter, char *s, int len) {

  return dummy_xship(f, filter, s, len);

}

int flate_xship(FILE *f, int filter, char *s, int len) {

  return dummy_xship(f, filter, s, len);

}

#endif /* HAVE_ZLIB */

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

/* lzw interface: LZW (=postscript level 2) compression with a85.

   This relies on lzw.c/h to do the actual compression. */