Application: gvSIG desktop » gvSIG raster

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

# 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}

#)

<project xmlns="http://maven.apache.org/POM/4.0.0"

	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

	<modelVersion>4.0.0</modelVersion>

	<artifactId>org.gvsig.jpotrace</artifactId>

	<packaging>jar</packaging>

	<version>2.0.0-SNAPSHOT</version>

	<name>libjni-potrace</name>

	<parent>

		<groupId>org.gvsig</groupId>

		<artifactId>gvsig-base-library-jni-pom</artifactId>

		<version>2.0-SNAPSHOT</version>

	</parent>

	<properties>

		<build-dir>${basedir}/../build</build-dir>

        <eclipse.project.name>libjni-potrace</eclipse.project.name>

	</properties>

	<build>

		<plugins>

			<!-- TODO: MAKE TESTS WORK AND REMOVE THIS OPTION -->

			<plugin>

				<groupId>org.apache.maven.plugins</groupId>

				<artifactId>maven-surefire-plugin</artifactId>

				<configuration>

					<skipTests>true</skipTests>

				</configuration>

			</plugin>

		</plugins>

	</build>

	<profiles>

		<profile>

			<id>windows-profile</id>

            <activation>

                <property>

                    <name>native-platform</name>

                    <value>win</value>

                </property>

            </activation>

			<properties>

				<build-dir>${basedir}\..\build</build-dir>

			</properties>

            <dependencies>

                <dependency>

                    <groupId>com.microsoft</groupId>

                    <artifactId>visualcppredist</artifactId>

                    <version>2008</version>

                    <classifier>${native-classifier}</classifier>

                    <type>tar.gz</type>

                </dependency>

            </dependencies>

		</profile>

		<profile>

			<id>linux-profile</id>

            <activation>

                <property>

                    <name>native-platform</name>

                    <value>linux</value>

                </property>

            </activation>

		</profile>

		<profile>

			<id>mac-profile</id>

            <activation>

                <property>

                    <name>native-platform</name>

                    <value>mac</value>

                </property>

            </activation>

		</profile>

	</profiles>

</project>

CMAKE_MINIMUM_REQUIRED(VERSION 2.4)

#cmake_minimum_required(VERSION 2.6)

PROJECT(potrace)

SET(VERSION "1.8")

SET(POTRACE "potrace")

SET(MKBITMAP "mkbitmap")

SET(MAKELIBRARY 1)

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

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

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

ADD_SUBDIRECTORY(src)

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

	<description>

		Compila la librería potrace 1.8

	</description>

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

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

	<property environment="env"/>

	<condition property="potrace_version" value="1.8.0">

		<os family="unix"/>

	</condition>

	<condition property="potrace_version" value="180">

		<os family="windows"/>

	</condition>

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

		<os family="unix"/>

	</condition>

	<condition property="cmake_generator" value="'Eclipse CDT4 - MinGW Makefiles'">

		<os family="windows"/>

	</condition>		

	<target name="main" description="prepare and compile natives" depends="clean,prepare-natives,compile-natives">

	</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="lib-dist"/>

		<delete dir="BMCMake"/>

	</target>

</project>

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

/* code for adaptive LZW compression, as used in PostScript. */

#include <stdlib.h>

#include <stdio.h>

#include <errno.h>

#include <string.h>

#include "lists.h"

#include "bitops.h"

#include "lzw.h"

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

/* compression state specification */

/* The compression algorithm follows the following specification,

   expressed as a state machine. A state is a triple {s,d,n}, where s

   is a string of input symbols, d is a dictionary, which is a

   function from strings to output symbols, and n is the dictionary

   size, or equivalently, the next unused output symbol. There are

   also special states init and stop. (emit.c[b]ode) is a function

   which emits the code code as a b-bit value into the output

   bitstream. hibit(n) returns the least number of binary digits

   required to represent n.

   init ---> {[], newdict, 258}

     where [] is the empty string, and newdict maps each of the 256

     singleton strings to itself. (Note that there are two special

     output symbols 256 and 257, so that the next available one is

     258). Note: hibit(258)=9.

   {[], d, n} (input c) ---> (emit[hibit(n)] 256) {c, d, n}

   {s,d,n} (input c) ---> {s*c,d,n}

     if s!=[], s*c is in the domain of d. Here s*c is the strings s

     extended by the character c.

   {s,d,n} (input c) ---> (emit.c[hibit(n)]ode) {c,d',n+1}

     if s!=[], s*c is not in the domain of d, and hibit(n+2) <= 12.

     Here, d(s)=code, and d'=d+{s*c->n}.

   {s,d,n} (input c) ---> 

           (emit.c[hibit(n)]ode) (emit[hibit(n+1)] 256) {c, newdict, 258}

     if s!=[], s*c is not in the domain of d, and hibit(n+2) > 12.

     Here, d(s)=code, and d'=d+{s*c->n}.

   {s,d,n} (input EOD) ---> (emit.c[hibit(n)]ode) (emit[hibit(n+1)] 257) stop

     where s != [], code = d(s). Here, EOD stands for end-of-data.

   {[],d,n} (input EOD) ---> (emit[hibit(n)] 256) (emit[hibit(258)] 257) stop

   Notes: 

   * Each reachable state {s,d,n} satisfies hibit(n+1) <= 12.

   * Only codes of 12 or fewer bits are emitted.

   * Each reachable state {s,d,n} satisfies s=[] or s is in the domain of d.

   * The domain of d is always prefix closed (except for the empty prefix)

   * The state machine is deterministic and non-blocking.

*/

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

/* private state */

#define BITBUF_TYPE unsigned int

/* the dictionary is implemented as a tree of strings under the prefix

   order. The tree is in turns represented as a linked list of

   lzw_dict_t structures, with "children" pointing to a node's first

   child, and "next" pointing to a node's next sibling. As an

   optimization, the top-level nodes (singleton strings) are

   implemented lazily, i.e., the corresponding entry is not actually

   created until it is accessed. */

struct lzw_dict_s {

  char c;      /* last character of string represented by this entry */

  int code;    /* code for the string represented by this entry */

  int freq;    /* how often searched? For optimization only */

  struct lzw_dict_s *children;  /* list of sub-entries */

  struct lzw_dict_s *next;      /* for making a linked list */

};

typedef struct lzw_dict_s lzw_dict_t;

/* A state {s,d,n} is represented by the "dictionary state" part of

   the lzw_state_t structure. Here, s is a pointer directly to the node

   of the dictionary structure corresponding to the string s, or NULL

   if s=[]. Further, the lzw_state_t structure contains a buffer of

   pending output bits, and a flag indicating whether the EOD (end of

   data) has been reached in the input. */

struct lzw_state_s {

  /* dictionary state */

  int n;           /* current size of the dictionary */

  lzw_dict_t *d;     /* pointer to dictionary */

  lzw_dict_t *s;     /* pointer to current string, or NULL at beginning */

  /* buffers for pending output */

  BITBUF_TYPE buf; /* bits scheduled for output - left aligned, 0 padded */

  int bufsize;     /* number of bits scheduled for output. */

  int eod;         /* flush buffer? */

};

typedef struct lzw_state_s lzw_state_t;

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

/* auxiliary functions which operate on dictionary states */

/* recursively free an lzw_dict_t object */

static void lzw_free_dict(lzw_dict_t *s) {

  lzw_dict_t *e;

  list_forall_unlink(e, s) {

    lzw_free_dict(e->children);

    free(e);

  }

}

/* re-initialize the lzw state's dictionary state to "newdict",

   freeing any old dictionary. */

static void lzw_clear_table(lzw_state_t *st) {

  lzw_free_dict(st->d);

  st->d = NULL;

  st->n = 258;

  st->s = NULL;

}

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

/* auxiliary functions for reading/writing the bit buffer */

/* write the code to the bit buffer. Precondition st->bufsize <= 7.

   Note: this does not change the dictionary state; in particular,

   n must be updated between consecutive calls. */

static inline void lzw_emit(int code, lzw_state_t *st) {

  BITBUF_TYPE mask;

  int bits = hibit(st->n);

  /* fill bit buffer */

  mask = (1 << bits) - 1;

  code &= mask;

  st->buf |= code << (8*sizeof(BITBUF_TYPE) - st->bufsize - bits);

  st->bufsize += bits;

}

/* transfer one byte from bit buffer to output. Precondition:

   s->avail_out > 0. */

static inline void lzw_read_bitbuf(lzw_stream_t *s) {

  int ch;

  lzw_state_t *st = (lzw_state_t *)s->internal;

  ch = st->buf >> (8*sizeof(BITBUF_TYPE)-8);

  st->buf <<= 8;

  st->bufsize -= 8;

  s->next_out[0] = ch;

  s->next_out++;

  s->avail_out--;

}

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

/* The following functions implement the state machine. */

/* perform state transition of the state st on input character

   ch. This updates the dictionary state and/or writes to the bit

   buffer. Precondition: st->bufsize <= 7. Return 0 on success, or 1

   on error with errno set. */

static int lzw_encode_char(lzw_state_t *st, char c) {

  lzw_dict_t *e;

  /* st = {s,d,n}. hibit(n+1)<=12. */

  /* {[], d, n} (input c) ---> (emit[hibit(n)] 256) {c, d, n} */

  if (st->s == NULL) {

    lzw_emit(256, st);

    goto singleton;  /* enter singleton state c */

  } 

  /* {s,d,n} (input c) ---> {s*c,d,n} */

  list_find(e, st->s->children, e->c == c);

  if (e) {

    e->freq++;

    st->s = e;

    return 0;

  }

  /* {s,d,n} (input c) ---> (emit.c[hibit(n)]ode) {c,d',n+1} */

  /* {s,d,n} (input c) --->

	     (emit.c[hibit(n)]ode) (emit[hibit(n+1)] 256) {c, newdict, 258} */

  lzw_emit(st->s->code, st); /* 9-12 bits */

  if (st->n >= 4094) {   /* hibit(n+2) > 12 */  /* ### was: 4093 */

    st->n++;

    lzw_emit(256, st);

    goto dictfull;    /* reset dictionary and enter singleton state c */

  }

  /* insert new code in dictionary, if possible */

  e = (lzw_dict_t *)malloc(sizeof(lzw_dict_t));

  if (!e) {

    return 1;

  }

  e->c = c;

  e->code = st->n;

  e->freq = 1;

  e->children = NULL;

  list_prepend(st->s->children, e);

  st->n++;

  goto singleton;  /* enter singleton state c */

 dictfull:    /* reset dictionary and enter singleton state c */

  lzw_clear_table(st);

  /* fall through */

 singleton:   /* enter singleton state c */

  list_find(e, st->d, e->c == c);

  if (!e) {  /* not found: lazily add it */

    e = (lzw_dict_t *)malloc(sizeof(lzw_dict_t));

    if (!e) {

      return 1;

    }

    e->c = c;

    e->code = (int)(unsigned char)c;

    e->freq = 0;

    e->children = NULL;

    list_prepend(st->d, e);

  }

  e->freq++;

  st->s = e;

  return 0;

}

/* perform state transition of the state st on input EOD. The leaves

   the dictionary state undefined and writes to the bit buffer.

   Precondition: st->bufsize <= 7. This function must be called

   exactly once, at the end of the stream. */

static void lzw_encode_eod(lzw_state_t *st) {

  /* {[],d,n} (input EOD) ---> 

              (emit[hibit(n)] 256) (emit[hibit(n+1)] 257) stop */

  if (st->s == NULL) {

    lzw_emit(256, st);  /* 9 bits */

    st->n=258;

    lzw_emit(257, st);  /* 9 bits */

    return;

  } 

  /* {s,d,n} (input EOD) ---> 

             (emit.c[hibit(n)]ode) (emit[hibit(n+1)] 257) stop */

  lzw_emit(st->s->code, st); /* 9-12 bits */

  st->n++;

  lzw_emit(257, st);  /* 9-12 bits */

  return;

}

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

/* User visible functions. These implement a buffer interface. See

   lzw.h for the API description. */

lzw_stream_t *lzw_init(void) {

  lzw_stream_t *s = NULL;

  lzw_state_t *st = NULL;

  s = (lzw_stream_t *)malloc(sizeof(lzw_stream_t));

  if (s==NULL) {

    goto fail;

  }

  st = (lzw_state_t *)malloc(sizeof(lzw_state_t));

  if (st==NULL) {

    goto fail;

  }

  st->buf = 0;

  st->bufsize = 0;

  st->eod = 0;

  st->d = NULL;

  lzw_clear_table(st);

  s->internal = (void *) st;

  return s;

 fail:

  free(s);

  free(st);

  return NULL;

}

int lzw_compress(lzw_stream_t *s, int mode) {

  int r;

  lzw_state_t *st = (lzw_state_t *)s->internal;

  while (st->eod == 0) {

    /* empty bit buffer */

    while (st->bufsize > 7) {

      if (s->avail_out == 0) {

	return 0;

      } else {

	lzw_read_bitbuf(s);

      }

    }

    /* fill bit buffer */

    if (s->avail_in == 0) {

      break;

    } else {

      r = lzw_encode_char(st, s->next_in[0]);

      if (r) {

	if (r==2) {

	  errno = EINVAL;

	}

	return 1;

      }

      s->next_in++;

      s->avail_in--;

    }

  }

  if (mode==LZW_EOD && st->eod == 0) {

    st->eod = 1;

    lzw_encode_eod(st);

  }

  /* flush bit buffer */

  if (st->eod) {

    while (st->bufsize > 0) {

      if (s->avail_out == 0) {

	return 0;

      } else {

	lzw_read_bitbuf(s);

      }

    }

  }

  return 0;

}

void lzw_free(lzw_stream_t *s) {

  lzw_state_t *st = (lzw_state_t *)s->internal;

  lzw_free_dict(st->d);

  free(st);

  free(s);

}

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

/* main function for testing and illustration purposes */

#ifdef LZW_MAIN

int main() {

  lzw_stream_t *s;

  int ch;

  char inbuf[100];

  char outbuf[100];

  int i, r;

  int mode;

  s = lzw_init();

  if (!s) {

    goto error;

  }

  mode = LZW_NORMAL;

  while (1) {

    /* fill inbuf */

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

      ch = fgetc(stdin);

      if (ch==EOF) {

	break;

      }

      inbuf[i] = ch;

    }

    if (i<100) {   /* end of input */

      mode = LZW_EOD;

    }

    /* compress */

    s->next_in = inbuf;

    s->avail_in = i;

    do {

      s->next_out = outbuf;

      s->avail_out = 100;

      r = lzw_compress(s, mode);

      if (r) {

	goto error;

      }

      fwrite(outbuf, 1, 100-s->avail_out, stdout);

    } while (s->avail_out==0);

    if (mode == LZW_EOD) {

      break;

    }

  }

  fflush(stdout);

  lzw_free(s);

  return 0;

 error:

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

  lzw_free(s);

  return 1;

}

#endif

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

#include <errno.h>

#include <math.h>

#include "getopt.h"

#include "main.h"

#include "platform.h"

#include "backend_pdf.h"

#include "backend_eps.h"

#include "backend_pgm.h"

#include "backend_svg.h"

#include "backend_gimp.h"

#include "backend_xfig.h"

#include "bitmap_io.h"

#include "auxiliary.h"

#ifndef M_PI

#define M_PI 3.14159265358979323846

#endif

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

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

/* backends and their characteristics */

struct backend_s {

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

	char *ext; /* file extension */

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

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

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

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

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

	/* per-bitmap function */

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

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

};

typedef struct backend_s backend_t;

static backend_t backend[] = { {"eps", ".eps", 0, 0, 0, NULL, page_eps, NULL, 1}, {"postscript", ".ps", 1, 0, 1,

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

		init_pdf, page_pdf, term_pdf, 1}, {"svg", ".svg", 0, 0, 0, NULL, page_svg, NULL, 1}, {"pgm", ".pgm", 0, 1, 1, NULL,

		page_pgm, NULL, 1}, {"gimppath", ".gimppath", 0, 1, 0, NULL, page_gimp, NULL, 1}, {"xfig", ".fig", 1, 0, 0, NULL,

		page_xfig, NULL, 0}, {NULL, NULL, 0, 0, 0, NULL, NULL, NULL}, };

struct info_s info;

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

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

/* callback function for progress bar */

struct simple_progress_s {

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

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

};

typedef struct simple_progress_s simple_progress_t;

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

	if (d.d) {

		return d.x * d.d;

	} else {

		return d.x * def;

	}

}

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

/* calculations with bitmap dimensions, positioning etc */

/* consider a rectangle spanned by the vectors (w,0) and (0,h). Rotate

 it counterclockwise by angle alpha. Then set the rect_t structure

 to the resulting rectangle, setting its bounding box, origin,

 x-basis and y-basis. */

static void rotate_dim(double alpha, double w, double h, rect_t *r) {

	double s, c, x0, x1, y0, y1;

	s = sin(alpha / 180 * M_PI);

	c = cos(alpha / 180 * M_PI);

	/* apply the transformation matrix to the basis vectors */

	x0 = c * w;

	x1 = s * w;

	y0 = -s * h;

	y1 = c * h;

	/* determine bounding box and origin relative to bounding box */

	r->bb[0] = fabs(x0) + fabs(y0);

	r->bb[1] = fabs(x1) + fabs(y1);

	r->orig[0] = -min(x0, 0) - min(y0, 0);

	r->orig[1] = -min(x1, 0) - min(y1, 0);

}

/* determine the dimensions of the output based on command line and

 image dimensions */

static void calc_dimensions(imginfo_t *imginfo) {

	double dim_def;

	double maxwidth, maxheight, sc;

	rect_t r;

	/* we take care of a special case: if one of the image dimensions is

	 0, we change it to 1. Such an image is empty anyway, so there

	 will be 0 paths in it. Changing the dimensions avoids division by

	 0 error in calculating scaling factors, bounding boxes and

	 such. This doesn't quite do the right thing in all cases, but it

	 is better than causing overflow errors or "nan" output in

	 backends.  Human users don't tend to process images of size 0

	 anyway; they might occur in some pipelines. */

	if (imginfo->pixwidth == 0) {

		imginfo->pixwidth = 1;

	}

	if (imginfo->pixheight == 0) {

		imginfo->pixheight = 1;

	}

	/* set the default dimension for width, height, margins */

	if (info.backend->pixel) {

		dim_def = DIM_PT;

	} else {

		dim_def = DEFAULT_DIM;

	}

	/* apply default dimension to width, height, margins */

	imginfo->width = info.width_d.x == UNDEF ? UNDEF : double_of_dim(info.width_d, dim_def);

	imginfo->height = info.height_d.x == UNDEF ? UNDEF : double_of_dim(info.height_d, dim_def);

	imginfo->lmar = info.lmar_d.x == UNDEF ? UNDEF : double_of_dim(info.lmar_d, dim_def);

	imginfo->rmar = info.rmar_d.x == UNDEF ? UNDEF : double_of_dim(info.rmar_d, dim_def);

	imginfo->tmar = info.tmar_d.x == UNDEF ? UNDEF : double_of_dim(info.tmar_d, dim_def);

	imginfo->bmar = info.bmar_d.x == UNDEF ? UNDEF : double_of_dim(info.bmar_d, dim_def);

	/* determine width and height from desired resolution / scaling

	 factor, if given */

	if (info.backend->pixel) {

		if (imginfo->width == UNDEF && info.sx != UNDEF) {

			imginfo->width = imginfo->pixwidth * info.sx;

		}

		if (imginfo->height == UNDEF && info.sy != UNDEF) {

			imginfo->height = imginfo->pixheight * info.sy;

		}

	} else {

		if (imginfo->width == UNDEF && info.rx != UNDEF) {

			imginfo->width = imginfo->pixwidth / info.rx * 72;

		}

		if (imginfo->height == UNDEF && info.ry != UNDEF) {

			imginfo->height = imginfo->pixheight / info.ry * 72;

		}

	}

	/* if one of width/height is specified, determine the other */

	if (imginfo->width == UNDEF && imginfo->height != UNDEF) {

		imginfo->width = imginfo->height / imginfo->pixheight * imginfo->pixwidth / info.stretch;

	} else

		if (imginfo->width != UNDEF && imginfo->height == UNDEF) {

			imginfo->height = imginfo->width / imginfo->pixwidth * imginfo->pixheight * info.stretch;

		}

	/* if width and height are still variable, figure them out */

	if (imginfo->width == UNDEF && imginfo->height == UNDEF) {

		if (info.backend->fixed) {

			/* in fixed-size backends, try to squeeze it between margins */

			maxwidth = UNDEF;

			maxheight = UNDEF;

			if (imginfo->lmar != UNDEF && imginfo->rmar != UNDEF) {

				maxwidth = info.paperwidth - imginfo->lmar - imginfo->rmar;

			}

			if (imginfo->bmar != UNDEF && imginfo->tmar != UNDEF) {

				maxheight = info.paperheight - imginfo->bmar - imginfo->tmar;

			}

			if (maxwidth == UNDEF && maxheight == UNDEF) {

				maxwidth = max(info.paperwidth - 144, info.paperwidth * 0.75);

				maxheight = max(info.paperheight - 144, info.paperheight * 0.75);

			}

			rotate_dim(info.angle, imginfo->pixwidth, imginfo->pixheight * info.stretch, &r);

			sc = min(maxwidth == UNDEF ? INFTY : maxwidth / r.bb[0], maxheight == UNDEF ? INFTY : maxheight / r.bb[1]);

			imginfo->width = imginfo->pixwidth * sc;

			imginfo->height = imginfo->pixheight * info.stretch * sc;

		} else

			if (info.backend->pixel) {

				/* in pixel-based backends, assume default scaling factor of 1 */

				imginfo->width = imginfo->pixwidth;

				imginfo->height = imginfo->pixheight * info.stretch;

			} else {

				/* otherwise, choose a default size based on the default paper format */

				maxwidth = max(info.paperwidth - 144, info.paperwidth * 0.75);

				maxheight = max(info.paperheight - 144, info.paperheight * 0.75);

				sc = min(maxwidth / imginfo->pixwidth, maxheight / imginfo->pixheight / info.stretch);

				imginfo->width = imginfo->pixwidth * sc;

				imginfo->height = imginfo->pixheight * info.stretch * sc;

			}

	}

	/* calculate coordinate system */

	rotate_dim(info.angle, imginfo->width, imginfo->height, &imginfo->trans);

	/* adjust margins */

	if (info.backend->fixed) {

		if (imginfo->lmar == UNDEF && imginfo->rmar == UNDEF) {

			imginfo->lmar = (info.paperwidth - imginfo->trans.bb[0]) / 2;

		} else

			if (imginfo->lmar == UNDEF) {

				imginfo->lmar = (info.paperwidth - imginfo->trans.bb[0] - imginfo->rmar);

			} else

				if (imginfo->lmar != UNDEF && imginfo->rmar != UNDEF) {

					imginfo->lmar += (info.paperwidth - imginfo->trans.bb[0] - imginfo->lmar - imginfo->rmar) / 2;

				}

		if (imginfo->bmar == UNDEF && imginfo->tmar == UNDEF) {

			imginfo->bmar = (info.paperheight - imginfo->trans.bb[1]) / 2;

		} else

			if (imginfo->bmar == UNDEF) {

				imginfo->bmar = (info.paperheight - imginfo->trans.bb[1] - imginfo->tmar);

			} else

				if (imginfo->bmar != UNDEF && imginfo->tmar != UNDEF) {

					imginfo->bmar += (info.paperheight - imginfo->trans.bb[1] - imginfo->bmar - imginfo->tmar) / 2;

				}

	} else {

		if (imginfo->lmar == UNDEF) {

			imginfo->lmar = 0;

		}

		if (imginfo->rmar == UNDEF) {

			imginfo->rmar = 0;

		}

		if (imginfo->bmar == UNDEF) {

			imginfo->bmar = 0;

		}

		if (imginfo->tmar == UNDEF) {

			imginfo->tmar = 0;

		}

	}

}

static FILE *my_fopen_read(const char *filename) {

	if (filename == NULL || strcmp(filename, "-") == 0) {

		return stdin;

	}

	return fopen(filename, "rb");

}

static FILE *my_fopen_write(const char *filename) {

	if (filename == NULL || strcmp(filename, "-") == 0) {

		return stdout;

	}

	return fopen(filename, "wb");

}

/* close a file, but do nothing is filename is NULL or "-" */

static void my_fclose(FILE *f, const char *filename) {

	if (filename == NULL || strcmp(filename, "-") == 0) {

		return;

	}

	fclose(f);

}

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

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

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

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

	simple_progress_t *p = (simple_progress_t *) data;

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

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

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

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

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

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

	if (d >= p->dnext) {

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

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

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

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

	}

}

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

 allocated simple_progress_t structure to avoid having to malloc it

 here and free it later. */

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

	const char *q, *s;

	int len;

	/* initialize callback function's data */

	p->dnext = 0;

	if (count != 0) {

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

	} else {

		s = filename;

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

			s = q + 1;

		}

		len = strlen(s);

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

		p->name[20] = 0;

		if (len > 20) {

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

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

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

		}

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

	}

	/* initialize progress parameters */

	prog->callback = &simple_progress;

	prog->data = (void *) p;

	prog->min = 0.0;

	prog->max = 1.0;

	prog->epsilon = 0.0;

	/* draw first progress bar */

	simple_progress(0.0, prog->data);

	return;

}

struct pageformat_s {

	char *name;

	int w, h;

};

typedef struct pageformat_s pageformat_t;

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

static pageformat_t pageformat[] = {

	{ "a4",        595,  842 },

	{ "a3",        842, 1191 },

	{ "a5",        421,  595 },

	{ "b5",        516,  729 },

	{ "letter",    612,  792 },

	{ "legal",     612, 1008 },

	{ "tabloid",   792, 1224 },

	{ "statement", 396,  612 },

	{ "executive", 540,  720 },

	{ "folio",     612,  936 },

	{ "quarto",    610,  780 },

	{ "10x14",     720, 1008 },

	{ NULL, 0, 0 },

};

struct turnpolicy_s {

	char *name;

	int n;

};

typedef struct turnpolicy_s turnpolicy_t;

/* names of turn policies */

static turnpolicy_t turnpolicy[] = {

	{"black",    POTRACE_TURNPOLICY_BLACK},

	{"white",    POTRACE_TURNPOLICY_WHITE},

	{"left",     POTRACE_TURNPOLICY_LEFT},

	{"right",    POTRACE_TURNPOLICY_RIGHT},

	{"minority", POTRACE_TURNPOLICY_MINORITY},

	{"majority", POTRACE_TURNPOLICY_MAJORITY},

	{"random",   POTRACE_TURNPOLICY_RANDOM},

	{NULL, 0},

};

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

	char *p;

	dim_t res;

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

	res.d = 0;

	if (p!=s) {

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

			res.d = DIM_IN;

			p += 2;

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

			res.d = DIM_CM;

			p += 2;

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

			res.d = DIM_MM;

			p += 2;

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

			res.d = DIM_PT;

			p += 2;

		}

	}

	if (endptr!=NULL) {

		*endptr = p;

	}

	return res;

}

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

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

	char *p, *q;

	dim_t dx, dy;

	dx = parse_dimension(s, &p);

	if (p==s) {

		goto fail;

	}

	if (*p != 'x') {

		goto fail;

	}

	p++;

	dy = parse_dimension(p, &q);

	if (q==p) {

		goto fail;

	}

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

		dy.d = dx.d;

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

		dx.d = dy.d;

	}

	*dxp = dx;

	*dyp = dy;

	if (endptr != NULL) {

		*endptr = q;

	}

	return;

 fail:

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

	*dxp = dx;

	*dyp = dy;

	if (endptr != NULL) {

		*endptr = s;

	}

	return;

}

#define OPT_GROUP     300

#define OPT_OPAQUE    301

#define OPT_FILLCOLOR 302

#define OPT_PROGRESS  303

static struct option longopts[] = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	{0, 0, 0, 0}

};

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

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

	int c;

	char *p;

	int i, j, r;

	dim_t dim, dimx, dimy;

	int matches, bestmatch;

	/* defaults */

	info.backend = &backend[0];

	info.debug = 0;

	info.width_d.x = UNDEF;

	info.height_d.x = UNDEF;

	info.rx = UNDEF;

	info.ry = UNDEF;

	info.sx = UNDEF;

	info.sy = UNDEF;

	info.stretch = 1;

	info.lmar_d.x = UNDEF;

	info.rmar_d.x = UNDEF;

	info.tmar_d.x = UNDEF;

	info.bmar_d.x = UNDEF;

	info.angle = 0;

	info.paperwidth = DEFAULT_PAPERWIDTH;

	info.paperheight = DEFAULT_PAPERHEIGHT;

	info.unit = 10;

	info.compress = 1;

	info.pslevel = 2;

	info.color = 0x000000;

	info.gamma = 2.2;

	info.param = potrace_param_default();

	if (!info.param) {

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

		exit(1);

	}

	info.longcoding = 0;

	info.outfile = NULL;

	info.blacklevel = 0.5;

	info.invert = 0;

	info.opaque = 0;

	info.group = 0;

	info.fillcolor = 0xffffff;

	info.progress = 0;

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

		switch (c) {

			case OPT_PROGRESS:

				info.progress = 1;

				break;

			case 'W':

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

				if (*p) {

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

					exit(1);

				}

				break;

			case 'H':

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