Application: gvSIG desktop

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

	}

}

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

}

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)

# 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: decompose.c 146 2007-04-09 00:43:46Z selinger $ */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <limits.h>

#include "potracelib.h"

#include "curve.h"

#include "lists.h"

#include "auxiliary.h"

#include "bitmap.h"

#include "decompose.h"

#include "progress.h"

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

/* auxiliary bitmap manipulations */

/* set the excess padding to 0 */

static void bm_clearexcess(potrace_bitmap_t *bm) {

  potrace_word mask;

  int y;

  if (bm->w % BM_WORDBITS != 0) {

    mask = BM_ALLBITS << (BM_WORDBITS - (bm->w % BM_WORDBITS));

    for (y=0; y<bm->h; y++) {

      *bm_index(bm, bm->w, y) &= mask;

    }

  }

}

struct bbox_s {

  int x0, x1, y0, y1;    /* bounding box */

};

typedef struct bbox_s bbox_t;

/* clear the bm, assuming the bounding box is set correctly (faster

   than clearing the whole bitmap) */

static void clear_bm_with_bbox(potrace_bitmap_t *bm, bbox_t *bbox) {

  int imin = (bbox->x0 / BM_WORDBITS);

  int imax = ((bbox->x1 + BM_WORDBITS-1) / BM_WORDBITS);

  int i, y;

  for (y=bbox->y0; y<bbox->y1; y++) {

    for (i=imin; i<imax; i++) {

      bm_scanline(bm, y)[i] = 0;

    }

  }

}

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

/* auxiliary functions */

/* deterministically and efficiently hash (x,y) into a pseudo-random bit */

static inline int detrand(int x, int y) {

  unsigned int z;

  static const unsigned char t[256] = { 

    /* non-linear sequence: constant term of inverse in GF(8), 

       mod x^8+x^4+x^3+x+1 */

    0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 

    0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 

    0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 

    1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 

    0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 

    0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 

    0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 

    0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 

    1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 

    0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 

    1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 

  };

  /* 0x04b3e375 and 0x05a8ef93 are chosen to contain every possible

     5-bit sequence */

  z = ((0x04b3e375 * x) ^ y) * 0x05a8ef93;

  z = t[z & 0xff] ^ t[(z>>8) & 0xff] ^ t[(z>>16) & 0xff] ^ t[(z>>24) & 0xff];

  return z & 1;

}

/* return the "majority" value of bitmap bm at intersection (x,y). We

   assume that the bitmap is balanced at "radius" 1.  */

static int majority(potrace_bitmap_t *bm, int x, int y) {

  int i, a, ct;

  for (i=2; i<5; i++) { /* check at "radius" i */

    ct = 0;

    for (a=-i+1; a<=i-1; a++) {

      ct += BM_GET(bm, x+a, y+i-1) ? 1 : -1;

      ct += BM_GET(bm, x+i-1, y+a-1) ? 1 : -1;

      ct += BM_GET(bm, x+a-1, y-i) ? 1 : -1;

      ct += BM_GET(bm, x-i, y+a) ? 1 : -1;

    }

    if (ct>0) {

      return 1;

    } else if (ct<0) {

      return 0;

    }

  }

  return 0;

}

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

/* decompose image into paths */

/* efficiently invert bits [x,infty) and [xa,infty) in line y. Here xa

   must be a multiple of BM_WORDBITS. */

static void xor_to_ref(potrace_bitmap_t *bm, int x, int y, int xa) {

  int xhi = x & -BM_WORDBITS;

  int xlo = x & (BM_WORDBITS-1);  /* = x % BM_WORDBITS */

  int i;

  if (xhi<xa) {

    for (i = xhi; i < xa; i+=BM_WORDBITS) {

      *bm_index(bm, i, y) ^= BM_ALLBITS;

    }

  } else {

    for (i = xa; i < xhi; i+=BM_WORDBITS) {

      *bm_index(bm, i, y) ^= BM_ALLBITS;

    }

  }

  /* note: the following "if" is needed because x86 treats a<<b as

     a<<(b&31). I spent hours looking for this bug. */

  if (xlo) {

    *bm_index(bm, xhi, y) ^= (BM_ALLBITS << (BM_WORDBITS - xlo));

  }

}

/* a path is represented as an array of points, which are thought to

   lie on the corners of pixels (not on their centers). The path point

   (x,y) is the lower left corner of the pixel (x,y). Paths are

   represented by the len/pt components of a path_t object (which

   also stores other information about the path) */

/* xor the given pixmap with the interior of the given path. Note: the

   path must be within the dimensions of the pixmap. */

static void xor_path(potrace_bitmap_t *bm, path_t *p) {

  int xa, x, y, k, y1;

  if (p->priv->len <= 0) {  /* a path of length 0 is silly, but legal */

    return;

  }

  y1 = p->priv->pt[p->priv->len-1].y;

  xa = p->priv->pt[0].x & -BM_WORDBITS;

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

    x = p->priv->pt[k].x;

    y = p->priv->pt[k].y;

    if (y != y1) {

      /* efficiently invert the rectangle [x,xa] x [y,y1] */

      xor_to_ref(bm, x, min(y,y1), xa);

      y1 = y;

    }

  }

}

/* Find the bounding box of a given path. Path is assumed to be of

   non-zero length. */

static void setbbox_path(bbox_t *bbox, path_t *p) {

  int x, y;

  int k;

  bbox->y0 = INT_MAX;

  bbox->y1 = 0;

  bbox->x0 = INT_MAX;

  bbox->x1 = 0;

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

    x = p->priv->pt[k].x;

    y = p->priv->pt[k].y;

    if (x < bbox->x0) {

      bbox->x0 = x;

    }

    if (x > bbox->x1) {

      bbox->x1 = x;

    }

    if (y < bbox->y0) {

      bbox->y0 = y;

    }

    if (y > bbox->y1) {

      bbox->y1 = y;

    }

  }

}

/* compute a path in the given pixmap, separating black from white.

   Start path at the point (x0,x1), which must be an upper left corner

   of the path. Also compute the area enclosed by the path. Return a

   new path_t object, or NULL on error (note that a legitimate path

   cannot have length 0). Sign is required for correct interpretation

   of turnpolicies. */

static path_t *findpath(potrace_bitmap_t *bm, int x0, int y0, int sign, int turnpolicy) {

  int x, y, dirx, diry, len, size, area;

  int c, d, tmp;

  point_t *pt, *pt1;

  path_t *p = NULL;

  x = x0;

  y = y0;

  dirx = 0;

  diry = -1;

  len = size = 0;

  pt = NULL;

  area = 0;

  while (1) {

    /* add point to path */

    if (len>=size) {

      size += 100;

      size = (int)(1.3 * size);

      pt1 = (point_t *)realloc(pt, size * sizeof(point_t));

      if (!pt1) {

	goto error;

      }

      pt = pt1;

    }

    pt[len].x = x;

    pt[len].y = y;

    len++;

    /* move to next point */

    x += dirx;

    y += diry;

    area += x*diry;

    /* path complete? */

    if (x==x0 && y==y0) {

      break;

    }

    /* determine next direction */

    c = BM_GET(bm, x + (dirx+diry-1)/2, y + (diry-dirx-1)/2);

    d = BM_GET(bm, x + (dirx-diry-1)/2, y + (diry+dirx-1)/2);

    if (c && !d) {               /* ambiguous turn */

      if (turnpolicy == POTRACE_TURNPOLICY_RIGHT

	  || (turnpolicy == POTRACE_TURNPOLICY_BLACK && sign == '+')

	  || (turnpolicy == POTRACE_TURNPOLICY_WHITE && sign == '-')

	  || (turnpolicy == POTRACE_TURNPOLICY_RANDOM && detrand(x,y))

	  || (turnpolicy == POTRACE_TURNPOLICY_MAJORITY && majority(bm, x, y))

	  || (turnpolicy == POTRACE_TURNPOLICY_MINORITY && !majority(bm, x, y))) {

	tmp = dirx;              /* right turn */

	dirx = diry;

	diry = -tmp;

      } else {

	tmp = dirx;              /* left turn */

	dirx = -diry;

	diry = tmp;

      }

    } else if (c) {              /* right turn */

      tmp = dirx;

      dirx = diry;

      diry = -tmp;

    } else if (!d) {             /* left turn */

      tmp = dirx;

      dirx = -diry;

      diry = tmp;

    }

  } /* while this path */

  /* allocate new path object */

  p = path_new();

  if (!p) {

    goto error;

  }

  p->priv->pt = pt;

  p->priv->len = len;

  p->area = area;

  p->sign = sign;

  return p;

 error:

   free(pt);

   return NULL; 

}

/* Give a tree structure to the given path list, based on "insideness"

   testing. I.e., path A is considered "below" path B if it is inside

   path B. The input pathlist is assumed to be ordered so that "outer"

   paths occur before "inner" paths. The tree structure is stored in

   the "childlist" and "sibling" components of the path_t

   structure. The linked list structure is also changed so that

   negative path components are listed immediately after their

   positive parent.  Note: some backends may ignore the tree

   structure, others may use it e.g. to group path components. We

   assume that in the input, point 0 of each path is an "upper left"

   corner of the path, as returned by bm_to_pathlist. This makes it

   easy to find an "interior" point. The bm argument should be a

   bitmap of the correct size (large enough to hold all the paths),

   and will be used as scratch space. Return 0 on success or -1 on

   error with errno set. */

static void pathlist_to_tree(path_t *plist, potrace_bitmap_t *bm) {

  path_t *p, *p1;

  path_t *heap, *heap1;

  path_t *cur;

  path_t *head;

  path_t **hook, **hook_in, **hook_out; /* for fast appending to linked list */

  bbox_t bbox;

  bm_clear(bm, 0);

  /* save original "next" pointers */

  list_forall(p, plist) {

    p->sibling = p->next;

    p->childlist = NULL;

  }

  heap = plist;

  /* the heap holds a list of lists of paths. Use "childlist" field

     for outer list, "next" field for inner list. Each of the sublists

     is to be turned into a tree. This code is messy, but it is

     actually fast. Each path is rendered exactly once. We use the

     heap to get a tail recursive algorithm: the heap holds a list of

     pathlists which still need to be transformed. */

  while (heap) {

    /* unlink first sublist */

    cur = heap;

    heap = heap->childlist;

    cur->childlist = NULL;

    /* unlink first path */

    head = cur;

    cur = cur->next;

    head->next = NULL;

    /* render path */

    xor_path(bm, head);

    setbbox_path(&bbox, head);

    /* now do insideness test for each element of cur; append it to

       head->childlist if it's inside head, else append it to

       head->next. */

    hook_in=&head->childlist;

    hook_out=&head->next;

    list_forall_unlink(p, cur) {

      if (p->priv->pt[0].y <= bbox.y0) {

	list_insert_beforehook(p, hook_out);

	/* append the remainder of the list to hook_out */

	*hook_out = cur;

	break;

      }

      if (BM_GET(bm, p->priv->pt[0].x, p->priv->pt[0].y-1)) {

	list_insert_beforehook(p, hook_in);

      } else {

	list_insert_beforehook(p, hook_out);

      }

    }

    /* clear bm */

    clear_bm_with_bbox(bm, &bbox);

    /* now schedule head->childlist and head->next for further

       processing */

    if (head->next) {

      head->next->childlist = heap;

      heap = head->next;

    }

    if (head->childlist) {

      head->childlist->childlist = heap;

      heap = head->childlist;

    }

  }

  /* copy sibling structure from "next" to "sibling" component */

  p = plist;

  while (p) {

    p1 = p->sibling;

    p->sibling = p->next;

    p = p1;

  }

  /* reconstruct a new linked list ("next") structure from tree

     ("childlist", "sibling") structure. This code is slightly messy,

     because we use a heap to make it tail recursive: the heap

     contains a list of childlists which still need to be

     processed. */

  heap = plist;

  if (heap) {

    heap->next = NULL;  /* heap is a linked list of childlists */

  }

  plist = NULL;

  hook = &plist;

  while (heap) {

    heap1 = heap->next;

    for (p=heap; p; p=p->sibling) {

      /* p is a positive path */

      /* append to linked list */

      list_insert_beforehook(p, hook);

      /* go through its children */

      for (p1=p->childlist; p1; p1=p1->sibling) {

	/* append to linked list */

	list_insert_beforehook(p1, hook);

	/* append its childlist to heap, if non-empty */

	if (p1->childlist) {

	  list_append(path_t, heap1, p1->childlist);

	}

      }

    }

    heap = heap1;

  }

  return;

}

/* find the next set pixel in a row <= y. Pixels are searched first

   left-to-right, then top-down. In other words, (x,y)<(x',y') if y>y'

   or y=y' and x<x'. If found, return 0 and store pixel in

   (*xp,*yp). Else return 1. Note that this function assumes that

   excess bytes have been cleared with bm_clearexcess. */

static int findnext(potrace_bitmap_t *bm, int *xp, int *yp) {

  int x;

  int y;

  for (y=*yp; y>=0; y--) {

    for (x=0; x<bm->w; x+=BM_WORDBITS) {

      if (*bm_index(bm, x, y)) {

	while (!BM_GET(bm, x, y)) {

	  x++;

	}

	/* found */

	*xp = x;

	*yp = y;

	return 0;

      }

    }

  }

  /* not found */

  return 1;

}

/* Decompose the given bitmap into paths. Returns a linked list of

   path_t objects with the fields len, pt, area, sign filled

   in. Returns 0 on success with plistp set, or -1 on error with errno

   set. */

int bm_to_pathlist(const potrace_bitmap_t *bm, path_t **plistp, const potrace_param_t *param, progress_t *progress) {

  int x;

  int y;

  path_t *p;

  path_t *plist = NULL;  /* linked list of path objects */

  path_t **hook = &plist;  /* used to speed up appending to linked list */

  potrace_bitmap_t *bm1 = NULL;

  int sign;

  bm1 = bm_dup(bm);

  if (!bm1) {

    goto error;

  }

  /* be sure the byte padding on the right is set to 0, as the fast

     pixel search below relies on it */

  bm_clearexcess(bm1);

  /* iterate through components */

  y = bm1->h - 1;

  while (findnext(bm1, &x, &y) == 0) { 

    /* calculate the sign by looking at the original */

    sign = BM_GET(bm, x, y) ? '+' : '-';

    /* calculate the path */

    p = findpath(bm1, x, y+1, sign, param->turnpolicy);

    if (p==NULL) {

	goto error;

    }

    /* update buffered image */

    xor_path(bm1, p);

    /* if it's a turd, eliminate it, else append it to the list */

    if (p->area <= param->turdsize) {

      path_free(p);

    } else {

      list_insert_beforehook(p, hook);

    }

    if (bm1->h > 0) { /* to be sure */

      progress_update(1-y/(double)bm1->h, progress);

    }

  }

  pathlist_to_tree(plist, bm1);

  bm_free(bm1);

  *plistp = plist;

  progress_update(1.0, progress);

  return 0;

 error:

  bm_free(bm1);

  list_forall_unlink(p, plist) {

    path_free(p);

  }

  return -1;

}

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

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

#include <string.h>

#include "render.h"

#include "greymap.h"

#include "auxiliary.h"

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

/* routines for anti-aliased rendering of curves */

/* we use the following method. Given a point (x,y) (with real-valued

   coordinates) in the plane, let (xi,yi) be the integer part of the

   coordinates, i.e., xi=floor(x), yi=floor(y). Define a path from

   (x,y) to infinity as follows: path(x,y) =

   (x,y)--(xi+1,y)--(xi+1,yi)--(+infty,yi).  Now as the point (x,y)

   moves smoothly across the plane, the path path(x,y) sweeps

   (non-smoothly) across a certain area. We proportionately blacken

   the area as the path moves "downward", and we whiten the area as

   the path moves "upward". This way, after the point has traversed a

   closed curve, the interior of the curve has been darkened

   (counterclockwise movement) or lightened (clockwise movement). (The

   "grey shift" is actually proportional to the winding number). By

   choosing the above path with mostly integer coordinates, we achieve

   that only pixels close to (x,y) receive grey values and are subject

   to round-off errors. The grey value of pixels far away from (x,y)

   is always in "integer" (where 0=black, 1=white).  As a special

   trick, we keep an accumulator rm->a1, which holds a double value to

   be added to the grey value to be added to the current pixel

   (xi,yi).  Only when changing "current" pixels, we convert this

   double value to an integer. This way we avoid round-off errors at

   the meeting points of line segments. Another speedup measure is

   that we sometimes use the rm->incrow_buf array to postpone

   incrementing or decrementing an entire row. If incrow_buf[y]=x+1!=0,

   then all the pixels (x,y),(x+1,y),(x+2,y),... are scheduled to be

   incremented/decremented (which one is the case will be clear from 

   context). This keeps the greymap operations reasonably local. */

/* allocate a new rendering state */

render_t *render_new(greymap_t *gm) {

  render_t *rm;

  rm = (render_t *) malloc(sizeof(render_t));

  if (!rm) {

    return NULL;

  }

  memset(rm, 0, sizeof(render_t));

  rm->gm = gm;

  rm->incrow_buf = (int *) malloc(gm->h * sizeof(int));

  if (!rm->incrow_buf) {

    free(rm);

    return NULL;

  }

  memset(rm->incrow_buf, 0, gm->h * sizeof(int));

  return rm;

}

/* free a given rendering state. Note: this does not free the

   underlying greymap. */

void render_free(render_t *rm) {

  free(rm->incrow_buf);

  free(rm);

}

/* close path */

void render_close(render_t *rm) {

  if (rm->x0 != rm->x1 || rm->y0 != rm->y1) {

    render_lineto(rm, rm->x0, rm->y0);

  }

  GM_INC(rm->gm, rm->x0i, rm->y0i, (rm->a0+rm->a1)*255);

  /* assert (rm->x0i != rm->x1i || rm->y0i != rm->y1i); */

  /* the persistent state is now undefined */

}

/* move point */

void render_moveto(render_t *rm, double x, double y) {

  /* close the previous path */

  render_close(rm);

  rm->x0 = rm->x1 = x;

  rm->y0 = rm->y1 = y;

  rm->x0i = (int)floor(rm->x0);

  rm->x1i = (int)floor(rm->x1);

  rm->y0i = (int)floor(rm->y0);

  rm->y1i = (int)floor(rm->y1);

  rm->a0 = rm->a1 = 0;

}

/* add b to pixels (x,y) and all pixels to the right of it. However,

   use rm->incrow_buf as a buffer to economize on multiple calls */

static void incrow(render_t *rm, int x, int y, int b) {

  int i, x0;

  if (y < 0 || y >= rm->gm->h) {

    return;

  }

  if (x < 0) {

    x = 0;

  } else if (x > rm->gm->w) {

    x = rm->gm->w;

  }

  if (rm->incrow_buf[y] == 0) {

    rm->incrow_buf[y] = x+1; /* store x+1 so that we can use 0 for "vacant" */

    return;

  }

  x0 = rm->incrow_buf[y]-1;

  rm->incrow_buf[y] = 0;

  if (x0 < x) {

    for (i=x0; i<x; i++) {

      GM_INC(rm->gm, i, y, -b);

    }

  } else {

    for (i=x; i<x0; i++) {

      GM_INC(rm->gm, i, y, b);

    }

  }    

}

/* render a straight line */

void render_lineto(render_t *rm, double x2, double y2) {

  int x2i, y2i;

  double t0=2, s0=2;

  int sn, tn;

  double ss=2, ts=2;

  double r0, r1;

  int i, j;

  int rxi, ryi;

  int s;

  x2i = (int)floor(x2);

  y2i = (int)floor(y2);

  sn = abs(x2i - rm->x1i);

  tn = abs(y2i - rm->y1i);

  if (sn) {

    s0 = ((x2>rm->x1 ? rm->x1i+1 : rm->x1i) - rm->x1)/(x2-rm->x1);

    ss = fabs(1.0/(x2-rm->x1));

  }

  if (tn) {

    t0 = ((y2>rm->y1 ? rm->y1i+1 : rm->y1i) - rm->y1)/(y2-rm->y1);

    ts = fabs(1.0/(y2-rm->y1));

  }

  r0 = 0;

  i = 0;

  j = 0;

  rxi = rm->x1i;

  ryi = rm->y1i;

  while (i<sn || j<tn) {

    if (j>=tn || (i<sn && s0+i*ss < t0+j*ts)) {

      r1 = s0+i*ss;

      i++;

      s = 1;

    } else {

      r1 = t0+j*ts;

      j++;

      s = 0;

    }

    /* render line from r0 to r1 segment of (rm->x1,rm->y1)..(x2,y2) */

    /* move point to r1 */

    rm->a1 += (r1-r0)*(y2-rm->y1)*(rxi+1-((r0+r1)/2.0*(x2-rm->x1)+rm->x1));

    /* move point across pixel boundary */

    if (s && x2>rm->x1) {

      GM_INC(rm->gm, rxi, ryi, rm->a1*255);

      rm->a1 = 0;

      rxi++;

      rm->a1 += rm->y1+r1*(y2-rm->y1)-ryi;

    } else if (!s && y2>rm->y1) {

      GM_INC(rm->gm, rxi, ryi, rm->a1*255);

      rm->a1 = 0;

      incrow(rm, rxi+1, ryi, 255);

      ryi++;

    } else if (s && x2<=rm->x1) {

      rm->a1 -= rm->y1+r1*(y2-rm->y1)-ryi;

      GM_INC(rm->gm, rxi, ryi, rm->a1*255);

      rm->a1 = 0;

      rxi--;

    } else if (!s && y2<=rm->y1) {

      GM_INC(rm->gm, rxi, ryi, rm->a1*255);

      rm->a1 = 0;

      ryi--;

      incrow(rm, rxi+1, ryi, -255);

    }

    r0 = r1;

  }

  /* move point to (x2,y2) */

  r1 = 1;

  rm->a1 += (r1-r0)*(y2-rm->y1)*(rxi+1-((r0+r1)/2.0*(x2-rm->x1)+rm->x1));

  rm->x1i = x2i;

  rm->y1i = y2i;

  rm->x1 = x2;

  rm->y1 = y2;

  /* assert (rxi != rm->x1i || ryi != rm->y1i); */

}

/* render a Bezier curve. */

void render_curveto(render_t *rm, double x2, double y2, double x3, double y3, double x4, double y4) {

  double x1, y1, dd0, dd1, dd, delta, e2, epsilon, t;

  x1 = rm->x1;  /* starting point */

  y1 = rm->y1;

  /* we approximate the curve by small line segments. The interval

     size, epsilon, is determined on the fly so that the distance

     between the true curve and its approximation does not exceed the

     desired accuracy delta. */

  delta = .1;  /* desired accuracy, in pixels */

  /* let dd = maximal value of 2nd derivative over curve - this must

     occur at an endpoint. */

  dd0 = sq(x1-2*x2+x3) + sq(y1-2*y2+y3);

  dd1 = sq(x2-2*x3+x4) + sq(y2-2*y3+y4);

  dd = 6*sqrt(max(dd0, dd1));

  e2 = 8*delta <= dd ? 8*delta/dd : 1;

  epsilon = sqrt(e2);  /* necessary interval size */

  for (t=epsilon; t<1; t+=epsilon) {

    render_lineto(rm, x1*cu(1-t)+3*x2*sq(1-t)*t+3*x3*(1-t)*sq(t)+x4*cu(t),

		  y1*cu(1-t)+3*y2*sq(1-t)*t+3*y3*(1-t)*sq(t)+y4*cu(t));

  }

  render_lineto(rm, x4, y4);

}

/* Copyright (C) 2001-2007 Peter Selinger.

   This file is part of Potrace. It is free software and it is covered

   by the GNU General Public License. See the file COPYING for details. */

#ifndef BITMAP_H

#define BITMAP_H

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <string.h>

#include <stdlib.h>

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

#include "potracelib.h"

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

   functions for accessing bitmaps. Since they only produce inline

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

   if desired */

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

/* some measurements */

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

#define BM_WORDBITS (8*BM_WORDSIZE)

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

#define BM_ALLBITS (~(potrace_word)0)

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

   bounds check. */

#define bm_scanline(bm, y) ((bm)->map + (y)*(bm)->dy)

#define bm_index(bm, x, y) (&bm_scanline(bm, y)[(x)/BM_WORDBITS])

#define bm_mask(x) (BM_HIBIT >> ((x) & (BM_WORDBITS-1)))

#define bm_range(x, a) ((int)(x) >= 0 && (int)(x) < (a))

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

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

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

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

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

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

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

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

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

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

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

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

static inline void bm_free(potrace_bitmap_t *bm) {

  if (bm) {

    free(bm->map);

  }

  free(bm);

}

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

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

  potrace_bitmap_t *bm;

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

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

  if (!bm) {

    return NULL;

  }

  bm->w = w;

  bm->h = h;

  bm->dy = dy;

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

  if (!bm->map) {

    free(bm);

    return NULL;

  }

  return bm;

}

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

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

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

}

/* duplicate the given bitmap. Return NULL on error with errno set. */

static inline potrace_bitmap_t *bm_dup(const potrace_bitmap_t *bm) {

  potrace_bitmap_t *bm1 = bm_new(bm->w, bm->h);

  if (!bm1) {

    return NULL;

  }

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

  return bm1;

}

/* invert the given bitmap. */

static inline void bm_invert(potrace_bitmap_t *bm) {

  int i;

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

    bm->map[i] ^= BM_ALLBITS;

  }

}

#endif /* BITMAP_H */

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

#define LZW_NORMAL 0

#define LZW_EOD 1

/* user visible state */

struct lzw_stream_s {

  char *next_in;     /* pointer to next input character */

  int avail_in;      /* number of input chars available */

  char *next_out;    /* pointer to next free byte in output buffer */

  int avail_out;     /* remaining size of output buffer */

  void *internal;    /* internal state, not user accessible */

};

typedef struct lzw_stream_s lzw_stream_t;

/* user visible functions */

/* The interface for compression and decompression is the same.  The

   application must first call lzw_init to create and initialize a

   compression object.  Then it calls lzw_compress on this object

   repeatedly, as follows: next_in and next_out must point to valid,

   non-overlapping regions of memory of size at least avail_in and

   avail_out, respectively.  The lzw_compress function will read and

   process as many input bytes as possible as long as there is room in

   the output buffer. It will update next_in, avail_in, next_out, and

   avail_out accordingly. Some input may be consumed without producing

   any output, or some output may be produced without consuming any

   input. However, the lzw_compress function makes progress in the

   sense that, after calling this function, at least one of avail_in

   or avail_out is guaranteed to be 0. The mode flag is normally set

   to LZW_NORMAL. It can be set to LZW_EOD (end of data) to indicate

   that the current input buffer represents the entire remaining input

   data stream.  When called with mode=LZW_EOD, and avail_out is

   non-zero after the call, then the application may conclude that the

   end of output has been reached. (However, if avail_out==0 after the

   call, then lzw_compress should be called again with the remaining

   input, if any). Finally, lzw_free should be called to deallocate

   the lzw_stream. Lzw_init returns NULL on error, with errno

   set. Lzw_compress returns 0 on success, and 1 on error with errno

   set. EINVAL is used to indicate an internal error, which should not

   happen. */

lzw_stream_t *lzw_init(void);

int lzw_compress(lzw_stream_t *s, int mode);

void lzw_free(lzw_stream_t *s);