Application: gvSIG desktop » gvSIG 3D

	<project name="libjni-potrace" default="main" basedir=".">

	<description>

		Compila la librería jpotrace

	</description>

	<property name="src-java" location="src/main/java" />

	<property name="src-tet-java" location="src/test/java" />

	<property name="jar-dist" location="jar-dist" />

	<property name="build" location="bin/" />

	<property name="cmake_build" location="." />

	<property environment="env"/>

	<condition property="jpotrace_version" value="0.0.1">

		<os family="unix"/>

	</condition>

	<condition property="jpotrace_version" value="001">

		<os family="windows"/>

	</condition>

	<property name="jpotrace-jar" location="jpotrace-0.0.1.jar" />

	<condition property="cmake_generator" value="'Unix Makefiles'">

		<os family="unix"/>

	</condition>

	<condition property="cmake_generator" value="'NMake Makefiles'">

		<os family="windows"/>

	</condition>		

	<target name="main" description="compile java code, make jars, prepare and compile natives" depends="clean,jar,prepare-natives,compile-natives">

	</target>

	<target name="jar" description="makes jar file">

		<mkdir dir="${build}" />

		<javac srcdir="${src-java}" destdir="${build}" debug="true" />

		<mkdir dir="${jar-dist}" />

		<jar jarfile="${jpotrace-jar}" basedir="${build}" includes="es/gva/cit/**, org/gvsig/**" />

		<move file="${jpotrace-jar}" todir="${jar-dist}" />

	</target>

	<target name="prepare-natives" description="prepares the natives to be compiled">

		<mkdir dir="${cmake_build}"/>

		<delete file="${cmake_build}/CMakeCache.txt"/>

		<exec dir="${cmake_build}" executable="cmake" os="Linux" >

			<arg line="." />

			<arg line="-G${cmake_generator}" />

			<arg line="-DCMAKE_BUILD_TYPE=Release" />

			<arg line="-DJPOTRACE_VERSION=${jpotrace_version}" />

		</exec>

		<exec dir="${cmake_build}" executable="cmake" os="Windows 98,Windows 2000,Windows XP,Windows NT (Unknown)">

			<arg line="." />

			<arg line="-G${cmake_generator}" />

			<arg line="-DCMAKE_BUILD_TYPE=Release" />

			<arg line="-DJPOTRACE_VERSION=${jpotrace_version}" />

		</exec>

	</target>

	<target name="compile-natives" description="compiles natives">

		<exec dir="${cmake_build}" executable="make" os="Linux">

		</exec>

		<exec dir="${cmake_build}" executable="nmake" os="Windows 98,Windows 2000,Windows XP,Windows NT (Unknown)">

			<arg line="install" />

		</exec>

	</target>

	<target name="clean" description="clean distribution">

		<delete dir="jar-dist"/>

		<delete dir="lib-dist"/>

		<delete dir="BMCMake"/>

	</target>

</project>

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

<classpath>

	<classpathentry kind="src" path="src/main/java"/>

	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>

	<classpathentry kind="output" path="bin"/>

</classpath>

<?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>

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

	}

}

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

	}

}

set(LIB_NAME jpotrace)

SET(POTRACE_VERSION "1.8")

SET(POTRACE "potrace")

SET(MKBITMAP "mkbitmap")

ADD_DEFINITIONS(-DPOTRACE=\\"${POTRACE}\\")

ADD_DEFINITIONS(-DVERSION=\\"${POTRACE_VERSION}\\")

ADD_DEFINITIONS(-DMKBITMAP=\\"${MKBITMAP}\\")

ADD_DEFINITIONS(-DHAVE_CONFIG_H)

FILE(GLOB HEADERS "*.h*")

SET(SOURCES 

	potrace.c

	potrace_raster.c

	potracelib.c

	bitmap_io.c

	backend_eps.c

	backend_gimp.c

	backend_pdf.c

	backend_pgm.c

	backend_svg.c

	backend_xfig.c

	decompose.c

	trace.c

	curve.c

	flate.c

	render.c

	greymap.c

	lzw.c

	getopt.c

	getopt1.c

)

include_directories(

	${CMAKE_SOURCE_DIR}/include

	${JAVA_INCLUDE_PATH}

	${JAVA_INCLUDE_PATH2}

)

SETUP_JNILIB(${LIB_NAME})

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

/* The Postscript backend of Potrace. This can produce "ps" or "eps"

   output, and different kinds of graphical debugging

   output. Postscript 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 "potracelib.h"

#include "curve.h"

#include "main.h"

#include "backend_eps.h"

#include "flate.h"

#include "lists.h"

#include "auxiliary.h"

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#define SAFE_MALLOC(var, n, typ) \

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

typedef int color_t;

#define black  0x000000

#define red    0xff0000

#define green  0x008000

#define blue   0x0000ff

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

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

  xship(xship_file, 1, buf, strlen(buf));

  return 0;

}  

/* ship a postscript comment, unfiltered */

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

  static char buf[4096];

  va_list args;

  va_start(args, fmt);

  vsprintf(buf, fmt, args);

  buf[4095] = 0;

  va_end(args);

  xship(xship_file, 0, buf, strlen(buf));

  return 0;

}

/* set all callback functions */

static void eps_callbacks(FILE *fout) {

  if (info.compress && info.pslevel==2) {

    xship = lzw_xship;

  } else if (info.compress && info.pslevel==3) {

    xship = flate_xship;

  } else {

    xship = dummy_xship;

  }

  xship_file = fout;

}  

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

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

}

/* current point */

static point_t cur;

static void eps_coords(dpoint_t p) {

  cur = unit(p);

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

}

static void eps_rcoords(dpoint_t p) {

  point_t q;

  q = unit(p);

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

  cur = q;

}

static void eps_moveto(dpoint_t p) {

  eps_coords(p);

  ship("moveto\n");

}

/* move to point + offset */

static void eps_moveto_offs(dpoint_t p, double xoffs, double yoffs) {

  /* note: structs are passed by value, so the following assignment

     does not modify the original struct in the caller */

  p.x += xoffs;

  p.y += yoffs;

  eps_coords(p);

  ship("moveto\n");

}

static void eps_lineto(dpoint_t p) {

  eps_rcoords(p);

  ship("rlineto\n");

}

static void eps_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 rcurveto\n", q1.x-cur.x, q1.y-cur.y, q2.x-cur.x, q2.y-cur.y, q3.x-cur.x, q3.y-cur.y);

  cur = q3;

}

/* this procedure returns a statically allocated string */

static char *eps_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 setgray";

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

    return "1 setgray";

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

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

    return buf;

  } else {

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

    return buf;

  }

}

static color_t eps_color = -1;

static double eps_width = -1;

static void eps_setcolor(const color_t col) {

  if (col == eps_color) {

    return;

  }

  eps_color = col;

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

}

static void eps_linewidth(double w) {

  if (w == eps_width) {

    return;

  }

  eps_width = w;

  ship("%f setlinewidth\n", w * info.unit);

}

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

/* functions for converting a path to postscript code */

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

/* ASCII encoding */

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

static int eps_path_long(privcurve_t *curve) {

  int i;

  dpoint_t *c;

  int m = curve->n;

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

  eps_moveto(c[2]);

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

    c = curve->c[i];

    switch (curve->tag[i]) {

    case POTRACE_CORNER:

      eps_lineto(c[1]);

      eps_lineto(c[2]);

      break;

    case POTRACE_CURVETO:

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

      break;

    }

  }

  return 0;

}

/* size-optimized encoding relies on special macros */

static int eps_path_short(privcurve_t *curve) {

  int i, i1;

  long int *bq = NULL;  /* bq[m] */

  long int *aq = NULL;  /* aq[m] */

  point_t *v = NULL;    /* v[m] */

  dpoint_t *q = NULL;   /* q[m] */

  double M;

  int m = curve->n;

  SAFE_MALLOC(bq, m, long int);

  SAFE_MALLOC(aq, m, long int);

  SAFE_MALLOC(v, m, point_t);

  SAFE_MALLOC(q, m, dpoint_t);

  /* quantize vertices */

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

    v[i] = unit(curve->vertex[i]);

  }

  /* quantize beta */

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

    i1 = mod(i+1,m);

    M = max(10, max(abs(v[i1].x-v[i].x), abs(v[i1].y-v[i].y)));

    bq[i] = (int)(M * curve->beta[i] + 0.5);

    if (curve->beta[i] != 0.5) {

      q[i1] = interval(bq[i]/M, dpoint(v[i]), dpoint(v[i1]));

    } else {

      q[i1] = interval(0.5, dpoint(v[i]), dpoint(v[i1]));

    }

  }

  /* quantize alpha */

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

    i1 = mod(i+1,m);

    M = max(10, max(max(abs(q[i].x-v[i].x), abs(q[i].y-v[i].y)),

		    max(abs(v[i].x-q[i1].x), abs(v[i].y-q[i1].y))));

    if (curve->tag[i] == POTRACE_CURVETO) {

      aq[i] = (int)(M * curve->alpha[i] + 0.5);

      if (aq[i] > M) {

	aq[i]--;

      }

    }

  }

  /* generate output */

  ship("%ld %ld ", v[m-1].x, v[m-1].y);

  ship("%ld %ld ", v[0].x - v[m-1].x, v[0].y - v[m-1].y);

  if (curve->beta[m-1] == 0.5) {

    ship("i\n");

  } else {

    ship("%ld I\n", bq[m-1]);

  }

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

    if (i<m-1) {

      ship("%ld %ld ", v[i+1].x - v[i].x, v[i+1].y - v[i].y);

      if (curve->beta[i] != 0.5) {

	ship("%ld ", bq[i]);

      }

    }

    if (curve->tag[i] == POTRACE_CURVETO) {

      ship(curve->beta[i] == 0.5 ? "%ld c\n" : "%ld C\n", aq[i]);

    } else {

      ship(curve->beta[i] == 0.5 ? "v\n" : "V\n");

    }

  }  

  free(bq);

  free(aq);

  free(v);

  free(q);

  return 0;

 malloc_error:

  free(bq);

  free(aq);

  free(v);

  free(q);

  return 1;

}

static int eps_path(privcurve_t *curve) {

  if (info.longcoding==0 && curve->alphacurve) {

    return eps_path_short(curve);

  } else {

    return eps_path_long(curve);

  }

}

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

/* functions for rendering various internal data structures, used to

   generate debugging output */

/* output jaggie curve in grey */

static void eps_jaggy(potrace_path_t *plist) {

  potrace_path_t *p;

  int i;

  ship(".9 setgray\n");

  list_forall (p, plist) {

    point_t *pt = p->priv->pt;

    point_t cur, prev;

    if (p->sign == '+') {

      cur = prev = pt[p->priv->len-1];

      eps_moveto(dpoint(cur));

      for (i=0; i<p->priv->len; i++) {

	if (pt[i].x != cur.x && pt[i].y != cur.y) {

	  cur = prev;

	  eps_lineto(dpoint(cur));

	}

	prev = pt[i];

      }

      eps_lineto(dpoint(pt[p->priv->len-1]));

    } else {

      cur = prev = pt[0];

      eps_moveto(dpoint(cur));

      for (i=p->priv->len-1; i>=0; i--) {

	if (pt[i].x != cur.x && pt[i].y != cur.y) {

          cur = prev;

          eps_lineto(dpoint(cur));

        }

        prev = pt[i];

      }

      eps_lineto(dpoint(pt[0]));

    }

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

      ship("fill\n");

    }

  }

}

/* output polygon */

static void eps_polygon(privcurve_t *curve, const color_t col) {

  int i;

  int m = curve->n;

  eps_linewidth(.02);

  eps_setcolor(col);

  eps_moveto(curve->vertex[m-1]);

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

    eps_lineto(curve->vertex[i]);

  }

  ship("stroke\n");

}

/* output lines L and parameter alpha */

static void eps_L(privcurve_t *curve, const color_t col) {

  int i, i1;

  double gamma;

  dpoint_t p1, p4, p1l, p4l;

  int m = curve->n;

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

    i1 = mod(i+1, m);

    gamma = curve->alpha0[i1] * 0.75;

    p1 = curve->c[i][2];

    p4 = curve->c[i1][2];

    p1l = interval(gamma, p1, curve->vertex[i1]);

    p4l = interval(gamma, p4, curve->vertex[i1]);

    eps_linewidth(.02);

    eps_setcolor(col);

    eps_moveto(p1l);

    eps_lineto(p4l);

    ship("stroke\n");

    eps_moveto_offs(curve->vertex[i1], -.4, -.4);

    ship("times (%.2f) show\n", curve->alpha0[i1]);

  }

}

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

/* postscript macros */

/* special macros for size-optimized rendering of Bezier curves */

static char *optimacros =

  "/D{bind def}def\n"

  "/R{roll}D\n"

  "/K{copy}D\n"

  "/P{pop}D\n"

  "/p{3 2 R add 3 1 R add exch}D\n"

  "/t{dup 4 3 R mul 3 1 R mul}D\n"

  "/a{dup 1 sub neg 4 1 R t 5 2 R t p}D\n"

  "/m{2 K le{exch}if P}D\n"

  "/n{abs exch abs m}D\n"

  "/d{-1 t p n}D\n"

  "/s{[4 2 R] cvx def}D\n"

  "/g{7 K P 4 K P P d 5 1 R d 10 m m div 5 K 12 8 R 5 4 R a 9 4 R 3 2 R a 6 4 R curveto}D\n"

  "/e{4 2 R lineto lineto P P}D\n"

  "/q{3 K P n 10 m div}D\n"

  "/f{x y 7 4 R 5 1 R 4 K p /y s 7 2 R 2 K 9 7 R 7 6 R t p 2 K /x s}D\n"

  "/C{4 1 R q f 7 6 R g}D\n"

  "/V{q f e}D\n"

  "/c{3 1 R .5 f 7 6 R g}D\n"

  "/v{.5 f e}D\n"

  "/j{5 K P p /y s 3 K t 7 5 R p /x s x moveto P}D\n"

  "/i{.5 j}D\n"

  "/I{dup 6 1 R q j 3 2 R}D\n"

  "/z{closepath}D\n"

  "/b{%s z fill}D\n"

  "/w{%s z fill}D\n";

/* special macros for debug output */

static char *debugmacros =

  "/unit { %f } def\n"

  "/box { newpath 0 0 moveto 0 1 lineto 1 1 lineto 1 0 lineto closepath } def\n"

  "/circ { newpath 0 0 1 0 360 arc closepath } def\n"

  "/dot { gsave .15 mul dup scale circ fill grestore } def\n"

  "/sq { gsave unit unit scale -.5 -.5 translate box .02 setlinewidth stroke grestore } def\n"

  "/sq1 { gsave translate sq unit .6 mul dot grestore } def\n"

  "/dot2 { gsave translate unit dot grestore } def\n"

  "/usq { gsave unit unit scale -.5 -.5 rmoveto 0 1 rlineto 1 0 rlineto 0 -1 rlineto closepath .02 setlinewidth stroke grestore } def\n"

  "/dot1 { gsave translate unit .3 mul dup scale circ fill grestore } def\n"

  "/times { /Times-Roman findfont unit .3 mul scalefont setfont } def\n"

  "/times1 { /Times-Roman findfont unit 10 mul scalefont setfont 0 0 0 setrgbcolor } def\n"

  "/times2 { /Times-Roman findfont unit 2 mul scalefont setfont 0 0 0 setrgbcolor } def\n";

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

/* Backends for various types of output. */

/* Normal output: black on transparent */

static int render0(potrace_path_t *plist) {

  potrace_path_t *p;

  if (info.longcoding) {

    eps_setcolor(info.color);

    list_forall (p, plist) {

      eps_path(p->priv->fcurve);

      ship("closepath\n");

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

	ship("fill\n");

      }

    }

  } else {

    list_forall (p, plist) {

      eps_path(p->priv->fcurve);

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

	ship("b\n");

      } else {

	ship("z\n");

      }

    }

  }

  return 0;

}

/* Opaque output: alternating black and white */

static int render0_opaque(potrace_path_t *plist) {

  potrace_path_t *p;

  if (info.longcoding) {

    list_forall (p, plist) {

      eps_path(p->priv->fcurve);

      ship("closepath\n");

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

      ship("fill\n");

    }

  } else {

    list_forall (p, plist) {

      eps_path(p->priv->fcurve);

      ship(p->sign=='+' ? "b\n" : "w\n");

    }

  }

  return 0;

}

/* Debug output type 1 (show optimal polygon) */

static int render1(potrace_path_t *plist) {

  potrace_path_t *p;

  int i;

  eps_jaggy(plist);

  list_forall (p, plist) {

    point_t *pt = p->priv->pt;

    int n = p->priv->len;

    int m = p->priv->m;

    int *po = p->priv->po;

    eps_linewidth(.02);

    eps_setcolor(black);

    /* output jaggie curve in boxed style */

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

      eps_moveto(dpoint(pt[i-1]));

      eps_lineto(dpoint(pt[i]));

      ship("stroke\n");

      eps_coords(dpoint(pt[i]));

      ship("sq1\n");

    }

    eps_moveto(dpoint(pt[n-1]));

    eps_lineto(dpoint(pt[0]));

    ship("stroke\n");

    eps_coords(dpoint(pt[0]));

    ship("sq1\n");

    /* output the uncorrected polygon */

    eps_linewidth(.1);

    eps_setcolor(blue);

    eps_moveto(dpoint(pt[po[0]]));

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

      eps_lineto(dpoint(pt[po[i]]));

    }

    eps_lineto(dpoint(pt[po[0]]));

    ship("stroke\n");

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

      eps_coords(dpoint(pt[po[i]]));

      ship("dot2\n");

    }

  }

  return 0;

}

/* Debug output type 2 (show corrected polygon and edge detection) */

static int render2(potrace_path_t *plist) {

  potrace_path_t *p;

  int i;

  /* output original bitmap in grey */

  eps_jaggy(plist);

  list_forall (p, plist) {

    /* output polygon with corrected edges, lines L, and parameter alpha */

    eps_polygon(&p->priv->curve, black);

    eps_L(&p->priv->curve, black);

    /* output the vertex unit squares */

    for (i=0; i<p->priv->curve.n; i++) {

      eps_moveto(p->priv->curve.vertex[i]);

      ship("usq\n");

    }

    /* output the path */

    eps_linewidth(.1);

    eps_setcolor(blue);

    eps_path(&p->priv->curve);

    ship("closepath\n");

    ship("stroke\n");

    if (info.param->opticurve && info.debug == 3) {

      /* output opticurve */

      eps_linewidth(.05);

      eps_setcolor(red);

      eps_path(&p->priv->ocurve);

      ship("closepath\n");

      ship("stroke\n");

      /* output dots */

      for (i=0; i<p->priv->ocurve.n; i++) {

	eps_coords(p->priv->ocurve.c[i][2]);

	ship("dot1\n");

      }

    }

  }

  return 0;

}

/* Free-style debug output */

static int render_debug(potrace_path_t *plist) {

  potrace_path_t *p;

  int count;

  int i;

  /* output original bitmap in grey */

  eps_jaggy(plist);

  count = -1;

  list_forall (p, plist) {

    count++;

    /* output path numbers */

    eps_moveto_offs(p->priv->curve.vertex[0], 0, 5);

    ship("times1 (%d) show\n", count);

    /* output polygon with corrected edges, lines L, and parameter alpha */

    eps_polygon(&p->priv->curve, black);

    eps_L(&p->priv->curve, black);

    /* output the vertex unit squares */

    for (i=0; i<p->priv->curve.n; i++) {

      eps_moveto(p->priv->curve.vertex[i]);

      ship("usq\n");

    }

    /* output the vertex numbers */

    for (i=0; i<p->priv->curve.n; i++) {

      eps_moveto_offs(p->priv->curve.vertex[i], +1, +1);

      ship("times2 (%d) show\n", i);

    }

    /* output the path */

    eps_linewidth(.1);

    eps_setcolor(blue);

    eps_path(&p->priv->curve);

    ship("closepath\n");

    ship("stroke\n");

    if (info.param->opticurve) {

      /* output the opti-verteces polygon */

      eps_polygon(&p->priv->ocurve, green);

      /* output opticurve */

      eps_linewidth(.05);

      eps_setcolor(red);

      eps_path(&p->priv->ocurve);

      ship("closepath\n");

      ship("stroke\n");

      /* output dots */

      for (i=0; i<p->priv->ocurve.n; i++) {

	eps_coords(p->priv->ocurve.c[i][2]);

	ship("dot1\n");

      }

      /* output beta parameters */

      for (i=0; i<p->priv->ocurve.n; i++) {

	eps_moveto_offs(p->priv->ocurve.c[i][2], +.4, -.4);

	ship("times (%.2f) show\n", p->priv->ocurve.beta[i]);

      }

    }

  }

  return 0;

}

/* select the appropriate rendering function from above */

static int eps_render(potrace_path_t *plist) {

  int r;

  switch (info.debug) {

  case 0:

    if (info.opaque) {

      r = render0_opaque(plist);

    } else {

      r = render0(plist);

    }

    break;

  case 1:

    r = render1(plist);

    break;

  case 2: case 3:

    r = render2(plist);

    break;

  default:

    r = render_debug(plist);

    break;

  }

  return r;

}  

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

/* EPS header and footer */

static int eps_init(imginfo_t *imginfo) {

  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;

  char *c0, *c1;

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

  shipcom("%%%%Creator: "POTRACE" "VERSION", written by Peter Selinger 2001-2007\n");

  shipcom("%%%%LanguageLevel: %d\n", info.pslevel);

  shipcom("%%%%BoundingBox: 0 0 %d %d\n", 

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

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

  shipcom("%%%%Pages: 1\n");

  shipcom("%%%%EndComments\n");

  shipcom("%%%%Page: 1 1\n");

  if (!info.longcoding) {

    c0 = strdup(eps_colorstring(info.color));

    c1 = strdup(eps_colorstring(info.fillcolor));

    ship(optimacros, c0, c1);

    free(c0);

    free(c1);

  }

  if (info.debug) {

    ship(debugmacros, info.unit);

  }

  ship("gsave\n");

  if (origx != 0 || origy != 0) {

    ship("%.0f %.0f translate\n", origx, origy);

  }

  if (info.angle != 0) {

    ship("%.2f rotate\n", info.angle);

  }

  ship("%f %f scale\n", scalex, scaley);

  return 0;

}

static int eps_term(void) {

  ship("grestore\n");

  shipcom("%%%%EOF\n");

  return 0;

}

/* public interface for EPS */

int page_eps(FILE *fout, potrace_path_t *plist, imginfo_t *imginfo) {

  int r;

  eps_callbacks(fout);

  eps_init(imginfo);

  r = eps_render(plist);

  if (r) {

    return r;

  }

  eps_term();

  return 0;

}

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

/* PostScript header and footer */

static int eps_pagenumber;

int init_ps(FILE *fout) {

  char *c0, *c1;

  /* set callback functions for shipping routines */

  eps_callbacks(fout);

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

  shipcom("%%%%Creator: "POTRACE" "VERSION", written by Peter Selinger 2001-2007\n");

  shipcom("%%%%LanguageLevel: %d\n", info.pslevel);

  shipcom("%%%%BoundingBox: 0 0 %d %d\n", info.paperwidth, info.paperheight);

  shipcom("%%%%Pages: (atend)\n");

  shipcom("%%%%EndComments\n");

  if (!info.longcoding || info.debug) {

    shipcom("%%%%BeginSetup\n");

    if (!info.longcoding) {

      c0 = strdup(eps_colorstring(info.color));

      c1 = strdup(eps_colorstring(info.fillcolor));

      ship(optimacros, c0, c1);

      free(c0);

      free(c1);

    }

    if (info.debug) {

      ship(debugmacros, info.unit);

    }

    shipcom("%%%%EndSetup\n");

  }

  eps_pagenumber = 0;

  fflush(fout);

  return 0;

}

int term_ps(FILE *fout) {

  eps_callbacks(fout);

  shipcom("%%%%Trailer\n");

  shipcom("%%%%Pages: %d\n", eps_pagenumber);

  shipcom("%%%%EOF\n");

  fflush(fout);

  return 0;

}

static void eps_pageinit_ps(imginfo_t *imginfo) {

  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;

  eps_pagenumber++;

  eps_color = -1;

  eps_width = -1;

  shipcom("%%%%Page: %d %d\n", eps_pagenumber, eps_pagenumber);

  ship("gsave\n");

  if (origx != 0 || origy != 0) {

    ship("%.0f %.0f translate\n", origx, origy);

  }

  if (info.angle != 0) {

    ship("%.2f rotate\n", info.angle);

  }

  ship("%f %f scale\n", scalex, scaley);

}

static void eps_pageterm_ps(void) {

  ship("grestore\n");

  ship("showpage\n");

}

int page_ps(FILE *fout, potrace_path_t *plist, imginfo_t *imginfo) {

  int r;

  eps_callbacks(fout);

  eps_pageinit_ps(imginfo);

  r = eps_render(plist);

  if (r) {

    return r;

  }

  eps_pageterm_ps();

  shipcom("");

  fflush(fout);

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

/* $Id: flate.h 147 2007-04-09 00:44:09Z selinger $ */

#ifndef FLATE_H

#define FLATE_H

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

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

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

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

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

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

/* Routines for manipulating bitmaps, including reading pbm files. */

#include <stdio.h>

#include "bitmap.h"

#define INTBITS (8*sizeof(int))

static int bm_readbody_bmp(FILE *f, double threshold, potrace_bitmap_t **bmp);

static int bm_readbody_pnm(FILE *f, double threshold, potrace_bitmap_t **bmp, int magic);

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

/* 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 bitmap. Return bitmap in *bmp. Return 0 on

 success, -1 on error with errno set, -2 on bad file format (with

 error message in bm_read_error), and 1 on premature end of file, -3

 on empty file (including files which contain only whitespace and

 comments), -4 if wrong magic number. If the return value is >=0,

 *bmp is valid. */

char *bm_read_error = NULL;

int bm_read(FILE *f, double threshold, potrace_bitmap_t **bmp) {

	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) {

		return -3;

	}

	magic[1] = fgetc(f);

	if (magic[0] == 'P' && magic[1] >= '1' && magic[1] <= '6') {

		return bm_readbody_pnm(f, threshold, bmp, magic[1]);

	}

	if (magic[0] == 'B' && magic[1] == 'M') {

		return bm_readbody_bmp(f, threshold, bmp);

	}

	return -4;

}

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

/* read PNM format */

/* read PNM stream after magic number. Return values as for bm_read */

static int bm_readbody_pnm(FILE *f, double threshold, potrace_bitmap_t **bmp, int magic) {

	potrace_bitmap_t *bm;

	int x, y, i, b, b1, sum;

	int bpr; /* bytes per row (as opposed to 4*bm->c) */

	int w, h, max;

	bm = NULL;

	w = readnum(f);

	if (w < 0) {

		goto format_error;

	}

	h = readnum(f);

	if (h < 0) {

		goto format_error;

	}

	/* allocate bitmap */

	bm = bm_new(w, h);

	if (!bm) {

		return -1;

	}

	/* zero it out */

	bm_clear(bm, 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;

					}

					BM_UPUT(bm, x, y, b);

				}

			}

			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;

					}

					BM_UPUT(bm, x, y, b > threshold * max ? 0 : 1);

				}

			}

			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;

					}

					BM_UPUT(bm, x, y, sum > 3 * threshold * max ? 0 : 1);

				}

			}

			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;

					}

					*bm_index(bm, i * 8, y) |= ((potrace_word) b) << (8 * (BM_WORDSIZE - 1 - (i % BM_WORDSIZE)));

				}

			}

			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;

					}

					BM_UPUT(bm, x, y, b > threshold * max ? 0 : 1);

				}

			}

			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;

					}

					BM_UPUT(bm, x, y, sum > 3 * threshold * max ? 0 : 1);

				}

			}

			break;

	}

	*bmp = bm;

	return 0;

	eof: *bmp = bm;

	return 1;

	format_error: bm_free(bm);

	if (magic == '1' || magic == '4') {

		bm_read_error = "invalid pbm file";

	} else

		if (magic == '2' || magic == '5') {

			bm_read_error = "invalid pgm file";

		} else {

			bm_read_error = "invalid ppm file";

		}

	return -2;

}

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

/* read BMP format */

struct bmp_info_s {

	unsigned int FileSize;

	unsigned int reserved;