Application: gvSIG desktop

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

	<description>

		Compila la librería jpotrace

	</description>

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

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

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

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

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

	<property environment="env"/>

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

		<os family="unix"/>

	</condition>

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

		<os family="windows"/>

	</condition>

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

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

		<os family="unix"/>

	</condition>

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

		<os family="windows"/>

	</condition>		

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

	</target>

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

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

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

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

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

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

	</target>

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

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

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

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

			<arg line="." />

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

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

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

		</exec>

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

			<arg line="." />

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

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

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

		</exec>

	</target>

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

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

		</exec>

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

			<arg line="install" />

		</exec>

	</target>

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

		<delete dir="jar-dist"/>

		<delete dir="lib-dist"/>

		<delete dir="BMCMake"/>

	</target>

</project>

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

<classpath>

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

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

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

</classpath>

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

<projectDescription>

	<name>libjni-potrace</name>

	<comment></comment>

	<projects>

	</projects>

	<buildSpec>

		<buildCommand>

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

			<arguments>

			</arguments>

		</buildCommand>

	</buildSpec>

	<natures>

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

	</natures>

</projectDescription>

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

/* $Id: backend_pdf.c 147 2007-04-09 00:44:09Z selinger $ */

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

	supplied via the functions in flate.c. */

#include <stdio.h>

#include <stdarg.h>

#include <string.h>

#include <math.h>

#include <stdlib.h>

#include "main.h"

#include "backend_pdf.h"

#include "flate.h"

#include "lists.h"

#include "potracelib.h"

#include "auxiliary.h"

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#ifndef M_PI

	#define M_PI 3.14159265358979323846

#endif

typedef int color_t;

#define black  0x000000

#define red    0xff0000

#define green  0x008000

#define blue   0x0000ff

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

/* auxiliary: growing arrays */

struct intarray_s {

  int size;

  int *data;

};

typedef struct intarray_s intarray_t;

static inline void intarray_init(intarray_t *ar) {

  ar->size = 0;

  ar->data = NULL;

}

static inline void intarray_term(intarray_t *ar) {

  free(ar->data);

  ar->size = 0;

  ar->data = NULL;

}

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

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

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

  int *p;

  int s;

  if (n >= ar->size) {

    s = n+1024;

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

    if (!p) {

      return -1;

    }

    ar->data = p;

    ar->size = s;

  }

  ar->data[n] = val;

  return 0;

}

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

/* some global variables */

static intarray_t xref;

static int nxref = 0;

static intarray_t pages;

static int npages;

static int streamofs;

static size_t outcount;  /* output file position */

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

/* functions for interfacing with compression backend */

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

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

   initialized too. */

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

   filter in case filter!=0 */

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

static FILE *xship_file;

/* ship PDF code, filtered */

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

  va_list args;

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

			    we only use constant format strings - for

			    the same reason, it is okay to use

			    vsprintf instead of vsnprintf below. */

  va_start(args, fmt);

  vsprintf(buf, fmt, args);

  buf[4095] = 0;

  va_end(args);

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

  return 0;

}  

/* ship PDF code, unfiltered */

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

  static char buf[4096];

  va_list args;

  va_start(args, fmt);

  vsprintf(buf, fmt, args);

  buf[4095] = 0;

  va_end(args);

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

  return 0;

}

/* set all callback functions */

static void pdf_callbacks(FILE *fout) {

  if (info.compress) {

    xship = pdf_xship;

  } else {

    xship = dummy_xship;

  }

  xship_file = fout;

}  

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

/* PDF path-drawing auxiliary functions */

/* coordinate quantization */

static inline point_t unit(dpoint_t p) {

  point_t q;

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

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

  return q;

}

static void pdf_coords(dpoint_t p) {

  point_t cur = unit(p);

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

}

static void pdf_moveto(dpoint_t p) {

  pdf_coords(p);

  ship("m\n");

}

static void pdf_lineto(dpoint_t p) {

  pdf_coords(p);

  ship("l\n");

}

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

  point_t q1, q2, q3;

  q1 = unit(p1);

  q2 = unit(p2);

  q3 = unit(p3);

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

}

/* this procedure returns a statically allocated string */

static char *pdf_colorstring(const color_t col) {

  double r, g, b;

  static char buf[100];

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

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

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

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

    return "0 g";

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

    return "1 g";

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

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

    return buf;

  } else {

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

    return buf;

  }

}

static color_t pdf_color = -1;

static double pdf_width = -1;

static void pdf_setcolor(const color_t col) {

  if (col == pdf_color) {

    return;

  }

  pdf_color = col;

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

}

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

static int pdf_path(potrace_curve_t *curve) {

  int i;

  dpoint_t *c;

  int m = curve->n;

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

  pdf_moveto(c[2]);

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

    c = curve->c[i];

    switch (curve->tag[i]) {

    case POTRACE_CORNER:

      pdf_lineto(c[1]);

      pdf_lineto(c[2]);

      break;

    case POTRACE_CURVETO:

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

      break;

    }

  }

  return 0;

}

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

/* Backends for various types of output. */

/* Normal output: black on transparent */

static int render0(potrace_path_t *plist) {

  potrace_path_t *p;

  pdf_setcolor(info.color);

  list_forall (p, plist) {

    pdf_path(&p->curve);

    ship("h\n");

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

      ship("f\n");

    }

  }

  return 0;

}

/* Opaque output: alternating black and white */

static int render0_opaque(potrace_path_t *plist) {

  potrace_path_t *p;

  list_forall (p, plist) {

    pdf_path(&p->curve);

    ship("h\n");

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

    ship("f\n");

  }

  return 0;

}

/* select the appropriate rendering function from above */

static int pdf_render(potrace_path_t *plist)

{

  if (info.opaque) {

    return render0_opaque(plist);

  }

  return render0(plist);

}  

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

/* PDF header and footer */

int init_pdf(FILE *fout)

{

        intarray_init(&xref);

	intarray_init(&pages);

	nxref = 0;

	npages = 0;

	/* set callback functions for shipping routines */

	pdf_callbacks(fout);

	outcount = 0;

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

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

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

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

	shipclear("2 0 obj\n"

		"<</Creator"

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

		"endobj\n");

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

	nxref++;

	fflush(fout);

	return 0;

}

int term_pdf(FILE *fout)

{

	int startxref;

	int i;

	pdf_callbacks(fout);

	intarray_set(&xref, 2, outcount);

	shipclear("3 0 obj\n"

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

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

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

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

	startxref = outcount;

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

	shipclear("0000000000 65535 f \n");

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

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

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

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

	fflush(fout);

	intarray_term(&xref);

	intarray_term(&pages);

	return 0;

}

static void pdf_pageinit(imginfo_t *imginfo)

{

	double s, c;

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

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

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

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

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

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

	pdf_color = -1;

	pdf_width = -1;

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

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

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

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

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

	shipclear("endobj\n");

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

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

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

	if (info.compress)

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

	else

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

	shipclear("stream\n");

	streamofs = outcount;

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

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

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

}

static void pdf_pageterm(void)

{

	int streamlen;

	shipclear("");

	streamlen = outcount - streamofs;

	shipclear("endstream\nendobj\n");

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

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

}

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

{

  int r;

  pdf_callbacks(fout);

  pdf_pageinit(imginfo);

  r = pdf_render(plist);

  if (r) {

    return r;

  }

  pdf_pageterm();

  fflush(fout);

  return 0;

}

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

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

 */

#ifndef POTRACE_RASTER_H

#define POTRACE_RASTER_H

#include "potracelib.h"

/* structure to hold a tilted rectangle */

struct rect_s {

	double bb[2];    /* dimensions of bounding box */

	double orig[2];  /* origin relative to bounding box */

};

typedef struct rect_s rect_t;

#ifdef USE_A4

#define DEFAULT_PAPERWIDTH 595

#define DEFAULT_PAPERHEIGHT 842

#define DEFAULT_PAPERFORMAT "a4"

#else

#define DEFAULT_PAPERWIDTH 612

#define DEFAULT_PAPERHEIGHT 792

#define DEFAULT_PAPERFORMAT "letter"

#endif

/* structure to hold a dimensioned value */

struct dim_s {

	double x; /* value */

	double d; /* dimension (in pt), or 0 if not given */

};

typedef struct dim_s dim_t;

/* structure to hold command line options */

struct info_s {

	struct backend_s *backend;  /* type of backend (eps,ps,pgm etc) */

	potrace_param_t *param;  /* tracing parameters, see potracelib.h */

	int debug;         /* type of output (0-2) (for BACKEND_PS/EPS only) */

	dim_t width_d;     /* desired width of image */

	dim_t height_d;    /* desired height of image */

	double rx;         /* desired x resolution (in dpi) */

	double ry;         /* desired y resolution (in dpi) */

	double sx;         /* desired x scaling factor */

	double sy;         /* desired y scaling factor */

	double stretch;    /* ry/rx, if not otherwise determined */

	dim_t lmar_d, rmar_d, tmar_d, bmar_d;   /* margins */

	double angle;      /* rotate by this many degrees */

	int paperwidth, paperheight;  /* paper size for ps backend (in pt) */

	double unit;       /* granularity of output grid */

	int compress;      /* apply compression? */

	int pslevel;       /* postscript level to use: affects only compression */

	int color;         /* rgb color code 0xrrggbb: line color */

	int fillcolor;     /* rgb color code 0xrrggbb: fill color */

	double gamma;      /* gamma value for pgm backend */

	int longcoding;    /* do not optimize for file size? */

	char *outfile;     /* output filename, if given */

	char **infiles;    /* array of input filenames */

	int infilecount;   /* number of input filenames */

	double blacklevel; /* 0 to 1: black/white cutoff in input file */

	int invert;        /* invert bitmap? */

	int opaque;        /* paint white shapes opaquely? */

	int group;         /* group paths together? */

	int progress;      /* should we display a progress bar? */

};

typedef struct info_s info_t;

extern info_t info;

/* structure to hold per-image information, set e.g. by calc_dimensions */

struct imginfo_s {

	int pixwidth;        /* width of input pixmap */

	int pixheight;       /* height of input pixmap */

	double width;        /* desired width of image (in pt or pixels) */

	double height;       /* desired height of image (in pt or pixels) */

	double lmar, rmar, tmar, bmar;   /* requested margins (in pt) */

	rect_t trans;        /* specify relative position of a tilted rectangle */

};

typedef struct imginfo_s imginfo_t;

double* vectorizarBuffer(const long *cbufferIn, int width, int height, int argc, char *argv[]);

#endif /* POTRACE_RASTER_H */

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

#ifndef RENDER_H

#define RENDER_H

#include "greymap.h"

struct render_s {

  greymap_t *gm;

  double x0, y0, x1, y1;

  int x0i, y0i, x1i, y1i;

  double a0, a1;

  int *incrow_buf;

};

typedef struct render_s render_t;

render_t *render_new(greymap_t *gm);

void render_free(render_t *rm);

void render_close(render_t *rm);

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

void render_lineto(render_t *rm, double x, double y);

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

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

#include <stdio.h>

#include <stdlib.h>

#include <errno.h>

#include <string.h>

#include <getopt.h>

#include <math.h>

#include "main.h"

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

#include "bitmap_io.h"

#include "bitmap.h"

#include "platform.h"

#include "auxiliary.h"

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

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

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;

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

}

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

/* some data structures for option processing */

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

};

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

};

/* look up a backend by name. If found, return 0 and set *bp. If not

   found leave *bp unchanged and return 1, or 2 on ambiguous

   prefix. */

static int backend_lookup(char *name, backend_t **bp) {

  int i;

  int m=0;  /* prefix matches */

  backend_t *b = NULL;

  for (i=0; backend[i].name; i++) {

    if (strcasecmp(backend[i].name, name)==0) {

      *bp = &backend[i];

      return 0;

    } else if (strncasecmp(backend[i].name, name, strlen(name))==0) {

      m++;

      b = &backend[i];

    }      

  }

  /* if there was no exact match, and exactly one prefix match, use that */

  if (m==1) {  

    *bp = b;

    return 0;

  } else if (m) {

    return 2;

  } else {

    return 1;

  }

}

/* list all available backends by name, in a comma separated list.

   Assume the cursor starts in column j, and break lines at length

   linelen. Do not output any trailing punctuation. Return the column

   the cursor is in. */

static int backend_list(FILE *fout, int j, int linelen) {

  int i;

  for (i=0; backend[i].name; i++) {

    if (j + (int)strlen(backend[i].name) > linelen) {

      fprintf(fout, "\n");

      j = 0;

    }

    j += fprintf(fout, "%s", backend[i].name);

    if (backend[i+1].name) {

      j += fprintf(fout, ", ");

    }

  }

  return j;

}

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

/* some info functions */

static void license(FILE *f) {

  fprintf(f, 

  "This program is free software; you can redistribute it and/or modify\n"

  "it under the terms of the GNU General Public License as published by\n"

  "the Free Software Foundation; either version 2 of the License, or\n"

  "(at your option) any later version.\n"

  "\n"

  "This program is distributed in the hope that it will be useful,\n"

  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"

  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"

  "GNU General Public License for more details.\n"

  "\n"

  "You should have received a copy of the GNU General Public License\n"

  "along with this program; if not, write to the Free Software\n"

  "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.\n"

	  );

}

static void show_defaults(FILE *f) {

  fprintf(f, "This version of Potrace was compiled with the following defaults:\n");

  fprintf(f, "Default unit: "DEFAULT_DIM_NAME"\n");

  fprintf(f, "Default page size: "DEFAULT_PAPERFORMAT"\n");

}

static void usage(FILE *f) {

  int j;

  fprintf(f, "Usage: "POTRACE" [options] [file...]\n");

  fprintf(f, "General options:\n");

  fprintf(f, " -h, --help                 - print this help message and exit\n");

  fprintf(f, " -v, --version              - print version info and exit\n");

  fprintf(f, " -l, --license              - print license info and exit\n");

  fprintf(f, " -V, --show-defaults        - print compiled-in defaults and exit\n");

  fprintf(f, " --progress                 - show progress bar\n");

  fprintf(f, "Input/output options:\n");

  fprintf(f, " -o, --output <file>        - output to file\n");

  fprintf(f, "Backend selection:\n");

  fprintf(f, " -e, --eps                  - EPS backend (encapsulated postscript) (default)\n");

  fprintf(f, " -p, --postscript           - Postscript backend\n");

  fprintf(f, " -s, --svg                  - SVG backend (scalable vector graphics)\n");

  fprintf(f, " -g, --pgm                  - PGM backend (portable greymap)\n");

  fprintf(f, " -b, --backend <name>       - select backend by name\n");

  fprintf(f, "Algorithm options:\n");

  fprintf(f, " -z, --turnpolicy <policy>  - how to resolve ambiguities in path decomposition\n");

  fprintf(f, " -t, --turdsize <n>         - suppress speckles of up to this size (default 2)\n");

  fprintf(f, " -a, --alphamax <n>         - corner threshold parameter (default 1)\n");

  fprintf(f, " -n, --longcurve            - turn off curve optimization\n");

  fprintf(f, " -O, --opttolerance <n>     - curve optimization tolerance (default 0.2)\n");

  fprintf(f, " -u, --unit <n>             - quantize output to 1/unit pixels (default 10)\n");

  fprintf(f, " -d, --debug <n>            - produce debugging output of type n (n=1,2,3)\n");

  fprintf(f, "Scaling and placement options:\n");

  fprintf(f, " -W, --width <dim>          - width of output image\n");

  fprintf(f, " -H, --height <dim>         - height of output image\n");

  fprintf(f, " -r, --resolution <n>[x<n>] - resolution (in dpi)\n");

  fprintf(f, " -x, --scale <n>[x<n>]      - scaling factor (pgm backend)\n");

  fprintf(f, " -S, --stretch <n>          - yresolution/xresolution\n");

  fprintf(f, " -A, --rotate <angle>       - rotate counterclockwise by angle\n");

  fprintf(f, " -M, --margin <dim>         - margin\n");

  fprintf(f, " -L, --leftmargin <dim>     - left margin\n");

  fprintf(f, " -R, --rightmargin <dim>    - right margin\n");

  fprintf(f, " -T, --topmargin <dim>      - top margin\n");