Application: gvSIG desktop

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

set(LIB_NAME jpotrace)

FILE(GLOB LIB_PUBLIC_HEADERS "${HEADER_PATH}/*.h")

FILE(GLOB LIB_COMMON_FILES "*.c*")

include_directories(

	${CMAKE_SOURCE_DIR}/include

	${JAVA_INCLUDE_PATH}

	${JAVA_INCLUDE_PATH2}

	${POTRACE_INCLUDE_DIR}

)

add_library(${LIB_NAME} SHARED 

	${LIB_PUBLIC_HEADERS}

	${LIB_COMMON_FILES}

)

target_link_libraries(${LIB_NAME}

	${POTRACE_LIBRARY}

)

if(APPLE)

SET_TARGET_PROPERTIES(${LIB_NAME}

	PROPERTIES

	SUFFIX .jnilib)

endif(APPLE)

INCLUDE(ModuleInstall OPTIONAL)

SET_TARGET_PROPERTIES(jpotrace PROPERTIES VERSION "${JPOTRACE_VERSION}")

IF(WIN32)

	SET_TARGET_PROPERTIES(jpotrace PROPERTIES OUTPUT_NAME "jpotrace${JPOTRACE_VERSION}")

ENDIF(WIN32)

IF(UNIX)

	SET_TARGET_PROPERTIES(jpotrace PROPERTIES OUTPUT_NAME "jpotrace${VERSION}")

ENDIF(UNIX)

IF(UNIX AND NOT APPLE)

	SET_TARGET_PROPERTIES ( ${LIB_NAME} PROPERTIES LINK_FLAGS "-Wl,-E")

ENDIF(UNIX AND NOT APPLE)

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

 */

#include <jni.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "potrace_raster.h"

/**

 * Parte de jni para vectorizar un buffer

 */

JNIEXPORT jdoubleArray JNICALL Java_org_gvsig_jpotrace_Potrace_vectorizeBufferRasterNat(JNIEnv *env, jclass clase, jintArray bufferIn, jint width, jint height, jobjectArray array) {

	int i;

	jint *cbufferIn;

	double *values;

	jsize size;

	jdoubleArray jvalues;

	jint length;

	char **list;

	cbufferIn = (*env)->GetIntArrayElements(env, bufferIn, NULL);

	length = (*env)->GetArrayLength(env, array);

	list = malloc(length * sizeof(char *));

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

		jobject string = (*env)->GetObjectArrayElement(env, array, i);

		list[i] = (char *) (*env)->GetStringUTFChars(env, string, NULL);

	}

	values = vectorizarBuffer((long *) cbufferIn, width, height, length, list);

	size = (jsize) values[0];

	jvalues = (*env)->NewDoubleArray(env, size);

	(*env)->SetDoubleArrayRegion(env, jvalues, 0, size, values);

	free(values);

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

		jobject string = (*env)->GetObjectArrayElement(env, array, i);

		(*env)->ReleaseStringUTFChars(env, string, list[i]);

	}

	free (list);

	return jvalues;

}

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

	}

}

# INSTALL and SOURCE_GROUP commands for OSG/OT/Producer Modules

# Required Vars:

# ${LIB_NAME}

# ${LIB_PUBLIC_HEADERS}

SET(INSTALL_INCDIR include)

SET(INSTALL_BINDIR bin)

IF(WIN32)

	SET(INSTALL_BINDIR .)

    SET(INSTALL_LIBDIR .)

    SET(INSTALL_ARCHIVEDIR lib)

ELSE(WIN32)

	SET(INSTALL_BINDIR .)

    SET(INSTALL_LIBDIR .)

    SET(INSTALL_ARCHIVEDIR lib)

ENDIF(WIN32)

SET(HEADERS_GROUP "Header Files")

SOURCE_GROUP(

    ${HEADERS_GROUP}

    FILES ${LIB_PUBLIC_HEADERS}

)

INSTALL(

    TARGETS ${LIB_NAME}

    RUNTIME DESTINATION ${INSTALL_BINDIR}

    LIBRARY DESTINATION ${INSTALL_LIBDIR}

    ARCHIVE DESTINATION ${INSTALL_ARCHIVEDIR}

)

# FIXME: Do not run for OS X framework

#INSTALL(

#    FILES        ${LIB_PUBLIC_HEADERS}

#    DESTINATION ${INSTALL_INCDIR}/${LIB_NAME}

#)

# Locate potrace

# This module defines

# POTRACE_LIBRARY

# POTRACE_FOUND, if false, do not try to link to potrace 

# POTRACE_INCLUDE_DIR, where to find the headers

#

# $POTRACE_DIR is an environment variable that would

# correspond to the ./configure --prefix=$POTRACE_DIR

#

# Created by Borja Sanchez Zamorano 

FIND_PATH(POTRACE_INCLUDE_DIR potracelib.h

	C:/workspace/workspace-HEADRASTER/potrace-1.8/src

	/home/borsanza/nacho/WRaster/potrace/src

)

FIND_LIBRARY(POTRACE_LIBRARY 

	NAMES libpotrace180 potrace POTRACE

	PATHS

	C:/workspace/workspace-HEADRASTER/binaries/w32

	/home/borsanza/nacho/WRaster/binaries/linux

)

SET(POTRACE_FOUND "NO")

IF(POTRACE_LIBRARY AND POTRACE_INCLUDE_DIR)

	SET(POTRACE_FOUND "YES")

ENDIF(POTRACE_LIBRARY AND POTRACE_INCLUDE_DIR)

IF(POTRACE_LIBRARY)

	MESSAGE(STATUS "POTRACE_LIBRARY: " ${POTRACE_LIBRARY})

ELSE(POTRACE_LIBRARY)

	MESSAGE(STATUS "POTRACE_LIBRARY: NOT FOUND")

ENDIF(POTRACE_LIBRARY)

IF(POTRACE_INCLUDE_DIR)

	MESSAGE(STATUS "POTRACE_INCLUDE_DIR: " ${POTRACE_INCLUDE_DIR})

ELSE(POTRACE_INCLUDE_DIR)

	MESSAGE(STATUS "POTRACE_INCLUDE_DIR: NOT FOUND")

ENDIF(POTRACE_INCLUDE_DIR)

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

<projectDescription>

	<name>potrace-Release@potrace-1.8</name>

	<comment></comment>

	<projects>

	</projects>

	<buildSpec>

		<buildCommand>

			<name>org.eclipse.cdt.make.core.makeBuilder</name>

			<triggers>clean,full,incremental,</triggers>

			<arguments>

				<dictionary>

					<key>org.eclipse.cdt.make.core.cleanBuildTarget</key>

					<value>clean</value>

				</dictionary>

				<dictionary>

					<key>org.eclipse.cdt.make.core.enableCleanBuild</key>

					<value>true</value>

				</dictionary>

				<dictionary>

					<key>org.eclipse.cdt.make.core.append_environment</key>

					<value>true</value>

				</dictionary>

				<dictionary>

					<key>org.eclipse.cdt.make.core.stopOnError</key>

					<value>true</value>

				</dictionary>

				<dictionary>

					<key>org.eclipse.cdt.make.core.enabledIncrementalBuild</key>

					<value>true</value>

				</dictionary>

				<dictionary>

					<key>org.eclipse.cdt.make.core.build.command</key>

					<value>C:/MinGW/bin/mingw32-make.exe</value>

				</dictionary>

				<dictionary>

					<key>org.eclipse.cdt.make.core.contents</key>

					<value>org.eclipse.cdt.make.core.activeConfigSettings</value>

				</dictionary>

				<dictionary>

					<key>org.eclipse.cdt.make.core.build.target.inc</key>

					<value>all</value>

				</dictionary>

				<dictionary>

					<key>org.eclipse.cdt.make.core.build.arguments</key>

					<value></value>

				</dictionary>

				<dictionary>

					<key>org.eclipse.cdt.make.core.buildLocation</key>

					<value>C:/workspace/workspace-HEADRASTER/potrace-1.8</value>

				</dictionary>

				<dictionary>

					<key>org.eclipse.cdt.make.core.useDefaultBuildCmd</key>

					<value>false</value>

				</dictionary>

				<dictionary>

					<key>org.eclipse.cdt.make.core.environment</key>

					<value></value>

				</dictionary>

				<dictionary>

					<key>org.eclipse.cdt.make.core.enableFullBuild</key>

					<value>true</value>

				</dictionary>

				<dictionary>

					<key>org.eclipse.cdt.make.core.build.target.auto</key>

					<value>all</value>

				</dictionary>

				<dictionary>

					<key>org.eclipse.cdt.make.core.enableAutoBuild</key>

					<value>false</value>

				</dictionary>

				<dictionary>

					<key>org.eclipse.cdt.make.core.build.target.clean</key>

					<value>clean</value>

				</dictionary>

				<dictionary>

					<key>org.eclipse.cdt.make.core.fullBuildTarget</key>

					<value>all</value>

				</dictionary>

				<dictionary>

					<key>org.eclipse.cdt.make.core.buildArguments</key>

					<value></value>

				</dictionary>

				<dictionary>

					<key>org.eclipse.cdt.make.core.build.location</key>

					<value>C:/workspace/workspace-HEADRASTER/potrace-1.8</value>

				</dictionary>

				<dictionary>

					<key>org.eclipse.cdt.make.core.autoBuildTarget</key>

					<value>all</value>

				</dictionary>

				<dictionary>

					<key>org.eclipse.cdt.core.errorOutputParser</key>

					<value>org.eclipse.cdt.core.MakeErrorParser;org.eclipse.cdt.core.GCCErrorParser;org.eclipse.cdt.core.GASErrorParser;org.eclipse.cdt.core.GLDErrorParser;</value>

				</dictionary>

			</arguments>

		</buildCommand>

		<buildCommand>

			<name>org.eclipse.cdt.make.core.ScannerConfigBuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

	</buildSpec>

	<natures>

		<nature>org.eclipse.cdt.core.ccnature</nature>

		<nature>org.eclipse.cdt.make.core.makeNature</nature>

		<nature>org.eclipse.cdt.make.core.ScannerConfigNature</nature>

		<nature>org.eclipse.cdt.core.cnature</nature>

	</natures>

</projectDescription>

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

<?fileVersion 4.0.0?>

<cproject>

<storageModule moduleId="org.eclipse.cdt.core.settings">

<cconfiguration id="org.eclipse.cdt.core.default.config.1">

<storageModule buildSystemId="org.eclipse.cdt.core.defaultConfigDataProvider" id="org.eclipse.cdt.core.default.config.1" moduleId="org.eclipse.cdt.core.settings" name="Configuration">

<externalSettings/>

<extensions>

<extension id="org.eclipse.cdt.core.PE" point="org.eclipse.cdt.core.BinaryParser"/>

</extensions>

</storageModule>

<storageModule moduleId="org.eclipse.cdt.core.language.mapping">

<project-mappings/>

</storageModule>

<storageModule moduleId="org.eclipse.cdt.core.externalSettings"/>

<storageModule moduleId="org.eclipse.cdt.core.pathentry">

<pathentry excluding="**/CMakeFiles/" kind="out" path=""/>

</storageModule>

<storageModule moduleId="org.eclipse.cdt.make.core.buildtargets">

<buildTargets>

<target name="all" path="" targetID="org.eclipse.cdt.make.MakeTargetBuilder">

<buildCommand>C:/MinGW/bin/mingw32-make.exe</buildCommand>

<buildArguments/>

<buildTarget>all</buildTarget>

<stopOnError>true</stopOnError>

<useDefaultCommand>false</useDefaultCommand>

</target>

<target name="preinstall" path="" targetID="org.eclipse.cdt.make.MakeTargetBuilder">

<buildCommand>C:/MinGW/bin/mingw32-make.exe</buildCommand>

<buildArguments/>

<buildTarget>preinstall</buildTarget>

<stopOnError>true</stopOnError>

<useDefaultCommand>false</useDefaultCommand>

</target>

<target name="clean" path="" targetID="org.eclipse.cdt.make.MakeTargetBuilder">

<buildCommand>C:/MinGW/bin/mingw32-make.exe</buildCommand>

<buildArguments/>

<buildTarget>clean</buildTarget>

<stopOnError>true</stopOnError>

<useDefaultCommand>false</useDefaultCommand>

</target>

<target name="edit_cache" path="" targetID="org.eclipse.cdt.make.MakeTargetBuilder">

<buildCommand>C:/MinGW/bin/mingw32-make.exe</buildCommand>

<buildArguments/>

<buildTarget>edit_cache</buildTarget>

<stopOnError>true</stopOnError>

<useDefaultCommand>false</useDefaultCommand>

</target>

<target name="install" path="" targetID="org.eclipse.cdt.make.MakeTargetBuilder">

<buildCommand>C:/MinGW/bin/mingw32-make.exe</buildCommand>

<buildArguments/>

<buildTarget>install</buildTarget>

<stopOnError>true</stopOnError>

<useDefaultCommand>false</useDefaultCommand>

</target>

<target name="install/strip" path="" targetID="org.eclipse.cdt.make.MakeTargetBuilder">

<buildCommand>C:/MinGW/bin/mingw32-make.exe</buildCommand>

<buildArguments/>

<buildTarget>install/strip</buildTarget>

<stopOnError>true</stopOnError>

<useDefaultCommand>false</useDefaultCommand>

</target>

<target name="rebuild_cache" path="" targetID="org.eclipse.cdt.make.MakeTargetBuilder">

<buildCommand>C:/MinGW/bin/mingw32-make.exe</buildCommand>

<buildArguments/>

<buildTarget>rebuild_cache</buildTarget>

<stopOnError>true</stopOnError>

<useDefaultCommand>false</useDefaultCommand>

</target>

<target name="potrace" path="" targetID="org.eclipse.cdt.make.MakeTargetBuilder">

<buildCommand>C:/MinGW/bin/mingw32-make.exe</buildCommand>

<buildArguments/>

<buildTarget>potrace</buildTarget>

<stopOnError>true</stopOnError>

<useDefaultCommand>false</useDefaultCommand>

</target>

<target name="potrace180" path="" targetID="org.eclipse.cdt.make.MakeTargetBuilder">

<buildCommand>C:/MinGW/bin/mingw32-make.exe</buildCommand>

<buildArguments/>

<buildTarget>potrace180</buildTarget>

<stopOnError>true</stopOnError>

<useDefaultCommand>false</useDefaultCommand>

</target>

</buildTargets>

</storageModule>

<storageModule moduleId="scannerConfiguration">

<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId="org.eclipse.cdt.make.core.GCCStandardMakePerProjectProfile"/>

<profile id="org.eclipse.cdt.make.core.GCCStandardMakePerProjectProfile">

<buildOutputProvider>

<openAction enabled="true" filePath=""/>

<parser enabled="true"/>

</buildOutputProvider>

<scannerInfoProvider id="specsFile">

<runAction arguments="-E -P -v -dD ${plugin_state_location}/${specs_file}" command="gcc" useDefault="true"/>

<parser enabled="true"/>

</scannerInfoProvider>

</profile>

<profile id="org.eclipse.cdt.make.core.GCCStandardMakePerFileProfile">

<buildOutputProvider>

<openAction enabled="true" filePath=""/>

<parser enabled="true"/>

</buildOutputProvider>

<scannerInfoProvider id="makefileGenerator">

<runAction arguments="-f ${project_name}_scd.mk" command="make" useDefault="true"/>

<parser enabled="true"/>

</scannerInfoProvider>

</profile>

</storageModule>

</cconfiguration>

</storageModule>

<storageModule moduleId="cdtBuildSystem" version="4.0.0">

<project id="potrace.null.1" name="potrace"/>

</storageModule>

</cproject>

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

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

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

#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: 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))