Mirrors
/
kicad
mirror of https://github.com/KiCad/kicad-source-mirror
3
0
Fork 0
Code Releases Activity
Browse Source

Update potrace to version 1.15 (that fixes some bugs)

pull/5/merge
jean-pierre charras 8 years ago
parent
e5847b7953
commit
23d1905c55
21 changed files with 1390 additions and 953 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 22
      potrace/auxiliary.h
  2. 226
      potrace/bitmap.h
  3. 338
      potrace/bitmap_io.cpp
  4. 4
      potrace/bitmap_io.h
  5. 33
      potrace/bitops.h
  6. 16
      potrace/curve.cpp
  7. 2
      potrace/curve.h
  8. 119
      potrace/decompose.cpp
  9. 9
      potrace/decompose.h
  10. 505
      potrace/greymap.cpp
  11. 53
      potrace/greymap.h
  12. 313
      potrace/lists.h
  13. 4
      potrace/platform.h
  14. 2
      potrace/potrace_version.h
  15. 14
      potrace/potracelib.cpp
  16. 17
      potrace/potracelib.h
  17. 22
      potrace/progress.h
  18. 71
      potrace/render.cpp
  19. 7
      potrace/render.h
  20. 561
      potrace/trace.cpp
  21. 5
      potrace/trace.h

22
potrace/auxiliary.h
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2001-2015 Peter Selinger.
/* Copyright (C) 2001-2017 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. */
@ -44,8 +44,8 @@ static inline dpoint_t interval( double lambda, dpoint_t a, dpoint_t b )
{
dpoint_t res;
res.x = a.x + lambda * (b.x - a.x);
res.y = a.y + lambda * (b.y - a.y);
res.x = a.x + lambda * ( b.x - a.x );
res.y = a.y + lambda * ( b.y - a.y );
return res;
}
@ -63,13 +63,13 @@ static inline dpoint_t interval( double lambda, dpoint_t a, dpoint_t b )
static inline int mod( int a, int n )
{
return a>=n ? a % n : a>=0 ? a : n - 1 - (-1 - a) % n;
return a >= n ? a % n : a >= 0 ? a : n - 1 - ( -1 - a ) % n;
}
static inline int floordiv( int a, int n )
{
return a>=0 ? a / n : -1 - (-1 - a) / n;
return a >= 0 ? a / n : -1 - ( -1 - a ) / n;
}
@ -80,11 +80,11 @@ static inline int floordiv( int a, int n )
#undef max
#undef sq
#undef cu
#define sign( x ) ( (x)>0 ? 1 : (x)<0 ? -1 : 0 )
#define abs( a ) ( (a)>0 ? (a) : -(a) )
#define min( a, b ) ( (a)<(b) ? (a) : (b) )
#define max( a, b ) ( (a)>(b) ? (a) : (b) )
#define sq( a ) ( (a) * (a) )
#define cu( a ) ( (a) * (a) * (a) )
#define sign( x ) ( ( x ) > 0 ? 1 : ( x ) < 0 ? -1 : 0 )
#define abs( a ) ( ( a ) > 0 ? ( a ) : -( a ) )
#define min( a, b ) ( ( a ) < ( b ) ? ( a ) : ( b ) )
#define max( a, b ) ( ( a ) > ( b ) ? ( a ) : ( b ) )
#define sq( a ) ( ( a ) * ( a ) )
#define cu( a ) ( ( a ) * ( a ) * ( a ) )
#endif /* AUXILIARY_H */

226
potrace/bitmap.h
View File

@ -1,14 +1,14 @@
/* Copyright (C) 2001-2015 Peter Selinger.
/* Copyright (C) 2001-2017 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
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
/* The bitmap type is defined in potracelib.h */
#include "potracelib.h"
@ -21,58 +21,117 @@
/* ---------------------------------------------------------------------- */
/* 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)
#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 + (ptrdiff_t) (y) * (ptrdiff_t) (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_scanline( bm, y ) ( ( bm )->map + (ptrdiff_t) ( y ) * (ptrdiff_t) ( 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)
#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 )
/* calculate the size, in bytes, required for the data area of a
* bitmap of the given dy and h. Assume h >= 0. Return -1 if the size
* does not fit into the ptrdiff_t type. */
static inline ptrdiff_t getsize( int dy, int h )
{
ptrdiff_t size;
if( dy < 0 )
{
dy = -dy;
}
size = (ptrdiff_t) dy * (ptrdiff_t) h * (ptrdiff_t) BM_WORDSIZE;
/* check for overflow error */
if( size < 0 || ( h != 0 && dy != 0 && size / h / dy != BM_WORDSIZE ) )
{
return -1;
}
return size;
}
/* return the size, in bytes, of the data area of the bitmap. Return
* -1 if the size does not fit into the ptrdiff_t type; however, this
* cannot happen if the bitmap is well-formed, i.e., if created with
* bm_new or bm_dup. */
static inline ptrdiff_t bm_size( const potrace_bitmap_t* bm )
{
return getsize( bm->dy, bm->h );
}
/* calculate the base address of the bitmap data. Assume that the
* bitmap is well-formed, i.e., its size fits into the ptrdiff_t type.
* This is the case if created with bm_new or bm_dup. The base address
* may differ from bm->map if dy is negative */
static inline potrace_word* bm_base( const potrace_bitmap_t* bm )
{
int dy = bm->dy;
if( dy >= 0 || bm->h == 0 )
{
return bm->map;
}
else
{
return bm_scanline( bm, bm->h - 1 );
}
}
/* free the given bitmap. Leaves errno untouched. */
static inline void bm_free( potrace_bitmap_t* bm )
{
if( bm )
if( bm && bm->map )
{
free( bm->map );
free( bm_base( bm ) );
}
free( bm );
}
/* return new un-initialized bitmap. NULL with errno on error.
/* return new bitmap initialized to 0. NULL with errno on error.
* Assumes w, h >= 0. */
static inline potrace_bitmap_t* bm_new( int w, int h )
{
potrace_bitmap_t* bm;
int dy = w == 0 ? 0 : (w - 1) / BM_WORDBITS + 1;
ptrdiff_t size = (ptrdiff_t) dy * (ptrdiff_t) h * (ptrdiff_t) BM_WORDSIZE;
int dy = w == 0 ? 0 : ( w - 1 ) / BM_WORDBITS + 1;
ptrdiff_t size;
/* check for overflow error */
if( size < 0 || (h != 0 && dy != 0 && size / h / dy != BM_WORDSIZE) )
size = getsize( dy, h );
if( size < 0 )
{
errno = ENOMEM;
return NULL;
}
bm = (potrace_bitmap_t*) malloc( sizeof(potrace_bitmap_t) );
if( size == 0 )
{
size = 1; /* make sure calloc() doesn't return NULL */
}
bm = (potrace_bitmap_t*) malloc( sizeof( potrace_bitmap_t ) );
if( !bm )
{
@ -82,7 +141,7 @@ static inline potrace_bitmap_t* bm_new( int w, int h )
bm->w = w;
bm->h = h;
bm->dy = dy;
bm->map = (potrace_word*) malloc( size );
bm->map = (potrace_word*) calloc( 1, size );
if( !bm->map )
{
@ -94,29 +153,36 @@ static inline potrace_bitmap_t* bm_new( int w, int h )
}
/* clear the given bitmap. Set all bits to c. */
/* clear the given bitmap. Set all bits to c. Assumes a well-formed
* bitmap. */
static inline void bm_clear( potrace_bitmap_t* bm, int c )
{
/* Note: if the bitmap was created with bm_new, then it is
* guaranteed that size will fit into the ptrdiff_t type. */
ptrdiff_t size = (ptrdiff_t) bm->dy * (ptrdiff_t) bm->h * (ptrdiff_t) BM_WORDSIZE;
ptrdiff_t size = bm_size( bm );
memset( bm->map, c ? -1 : 0, size );
memset( bm_base( bm ), c ? -1 : 0, size );
}
/* duplicate the given bitmap. Return NULL on error with errno set. */
/* duplicate the given bitmap. Return NULL on error with errno
* set. Assumes a well-formed bitmap. */
static inline potrace_bitmap_t* bm_dup( const potrace_bitmap_t* bm )
{
potrace_bitmap_t* bm1 = bm_new( bm->w, bm->h );
ptrdiff_t size = (ptrdiff_t) bm->dy * (ptrdiff_t) bm->h * (ptrdiff_t) BM_WORDSIZE;
int y;
if( !bm1 )
{
return NULL;
}
memcpy( bm1->map, bm->map, size );
for( y = 0; y < bm->h; y++ )
{
memcpy( bm_scanline( bm1, y ), bm_scanline( bm, y ),
(size_t) bm1->dy * (size_t) BM_WORDSIZE );
}
return bm1;
}
@ -124,13 +190,99 @@ static inline potrace_bitmap_t* bm_dup( const potrace_bitmap_t* bm )
/* invert the given bitmap. */
static inline void bm_invert( potrace_bitmap_t* bm )
{
ptrdiff_t i;
ptrdiff_t size = (ptrdiff_t) bm->dy * (ptrdiff_t) bm->h;
int dy = bm->dy;
int y;
int i;
potrace_word* p;
for( i = 0; i < size; i++ )
if( dy < 0 )
{
bm->map[i] ^= BM_ALLBITS;
dy = -dy;
}
for( y = 0; y < bm->h; y++ )
{
p = bm_scanline( bm, y );
for( i = 0; i < dy; i++ )
{
p[i] ^= BM_ALLBITS;
}
}
}
/* turn the given bitmap upside down. This does not move the bitmap
* data or change the bm_base() address. */
static inline void bm_flip( potrace_bitmap_t* bm )
{
int dy = bm->dy;
if( bm->h == 0 || bm->h == 1 )
{
return;
}
bm->map = bm_scanline( bm, bm->h - 1 );
bm->dy = -dy;
}
/* resize the bitmap to the given new height. The bitmap data remains
* bottom-aligned (truncated at the top) when dy >= 0 and top-aligned
* (truncated at the bottom) when dy < 0. Return 0 on success, or 1 on
* error with errno set. If the new height is <= the old one, no error
* should occur. If the new height is larger, the additional bitmap
* data is *not* initialized. */
static inline int bm_resize( potrace_bitmap_t* bm, int h )
{
int dy = bm->dy;
ptrdiff_t newsize;
potrace_word* newmap;
if( dy < 0 )
{
bm_flip( bm );
}
newsize = getsize( dy, h );
if( newsize < 0 )
{
errno = ENOMEM;
goto error;
}
if( newsize == 0 )
{
newsize = 1; /* make sure realloc() doesn't return NULL */
}
newmap = (potrace_word*) realloc( bm->map, newsize );
if( newmap == NULL )
{
goto error;
}
bm->map = newmap;
bm->h = h;
if( dy < 0 )
{
bm_flip( bm );
}
return 0;
error:
if( dy < 0 )
{
bm_flip( bm );
}
return 1;
}

338
potrace/bitmap_io.cpp
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2001-2015 Peter Selinger.
/* Copyright (C) 2001-2017 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. */
@ -12,13 +12,24 @@
#include <stdio.h>
#include "bitmap.h"
#include "bitmap_io.h"
#include "bitops.h"
#define INTBITS ( 8 * sizeof(int) )
#define INTBITS ( 8 * sizeof( int ) )
static int bm_readbody_bmp( FILE* f, double threshold, potrace_bitmap_t** bmp );
static int bm_readbody_pnm( FILE* f, double threshold, potrace_bitmap_t** bmp, int magic );
#define TRY( x ) \
if( x ) \
goto try_error
#define TRY_EOF( x ) \
if( x ) \
goto eof
#define TRY_STD( x ) \
if( x ) \
goto std_error
/* ---------------------------------------------------------------------- */
/* routines for reading pnm streams */
@ -32,13 +43,13 @@ static int fgetc_ws( FILE* f )
{
c = fgetc( f );
if( c=='#' )
if( c == '#' )
{
while( 1 )
{
c = fgetc( f );
if( c=='\n' || c==EOF )
if( c == '\n' || c == EOF )
{
break;
}
@ -46,7 +57,7 @@ static int fgetc_ws( FILE* f )
}
/* space, tab, line feed, carriage return, form-feed */
if( c!=' ' && c!='\t' && c!='\r' && c!='\n' && c!=12 )
if( c != ' ' && c != '\t' && c != '\r' && c != '\n' && c != 12 )
{
return c;
}
@ -69,12 +80,12 @@ static int readnum( FILE* f )
{
c = fgetc_ws( f );
if( c==EOF )
if( c == EOF )
{
return -1;
}
if( c>='0' && c<='9' )
if( c >= '0' && c <= '9' )
{
break;
}
@ -87,12 +98,12 @@ static int readnum( FILE* f )
{
c = fgetc( f );
if( c==EOF )
if( c == EOF )
{
break;
}
if( c<'0' || c>'9' )
if( c < '0' || c > '9' )
{
ungetc( c, f );
break;
@ -118,12 +129,12 @@ static int readbit( FILE* f )
{
c = fgetc_ws( f );
if( c==EOF )
if( c == EOF )
{
return -1;
}
if( c>='0' && c<='1' )
if( c >= '0' && c <= '1' )
{
break;
}
@ -185,21 +196,23 @@ static int bm_readbody_pnm( FILE* f, double threshold, potrace_bitmap_t** bmp, i
{
potrace_bitmap_t* bm;
int x, y, i, b, b1, sum;
int bpr; /* bytes per row (as opposed to 4*bm->c) */
int bpr; /* bytes per row (as opposed to 4*bm->c) */
int w, h, max;
int realheight; /* in case of incomplete file, keeps track of how
* many scan lines actually contain data */
bm = NULL;
w = readnum( f );
if( w<0 )
if( w < 0 )
{
goto format_error;
}
h = readnum( f );
if( h<0 )
if( h < 0 )
{
goto format_error;
}
@ -209,11 +222,10 @@ static int bm_readbody_pnm( FILE* f, double threshold, potrace_bitmap_t** bmp, i
if( !bm )
{
return -1;
goto std_error;
}
/* zero it out */
bm_clear( bm, 0 );
realheight = 0;
switch( magic )
{
@ -224,13 +236,15 @@ static int bm_readbody_pnm( FILE* f, double threshold, potrace_bitmap_t** bmp, i
case '1':
/* read P1 format: PBM ascii */
for( y = h - 1; y>=0; y-- )
for( y = 0; y < h; y++ )
{
for( x = 0; x<w; x++ )
realheight = y + 1;
for( x = 0; x < w; x++ )
{
b = readbit( f );
if( b<0 )
if( b < 0 )
{
goto eof;
}
@ -246,18 +260,20 @@ static int bm_readbody_pnm( FILE* f, double threshold, potrace_bitmap_t** bmp, i
max = readnum( f );
if( max<1 )
if( max < 1 )
{
goto format_error;
}
for( y = h - 1; y>=0; y-- )
for( y = 0; y < h; y++ )
{
for( x = 0; x<w; x++ )
realheight = y + 1;
for( x = 0; x < w; x++ )
{
b = readnum( f );
if( b<0 )
if( b < 0 )
{
goto eof;
}
@ -273,22 +289,24 @@ static int bm_readbody_pnm( FILE* f, double threshold, potrace_bitmap_t** bmp, i
max = readnum( f );
if( max<1 )
if( max < 1 )
{
goto format_error;
}
for( y = h - 1; y>=0; y-- )
for( y = 0; y < h; y++ )
{
for( x = 0; x<w; x++ )
realheight = y + 1;
for( x = 0; x < w; x++ )
{
sum = 0;
for( i = 0; i<3; i++ )
for( i = 0; i < 3; i++ )
{
b = readnum( f );
if( b<0 )
if( b < 0 )
{
goto eof;
}
@ -307,27 +325,28 @@ static int bm_readbody_pnm( FILE* f, double threshold, potrace_bitmap_t** bmp, i
b = fgetc( f ); /* read single white-space character after height */
if( b==EOF )
if( b == EOF )
{
goto format_error;
}
bpr = (w + 7) / 8;
bpr = ( w + 7 ) / 8;
for( y = h - 1; y>=0; y-- )
for( y = 0; y < h; y++ )
{
for( i = 0; i<bpr; i++ )
realheight = y + 1;
for( i = 0; i < bpr; i++ )
{
b = fgetc( f );
if( b==EOF )
if( b == EOF )
{
goto eof;
}
*bm_index( bm, i * 8,
y ) |= ( (potrace_word) b ) <<
( 8 * ( BM_WORDSIZE - 1 - (i % BM_WORDSIZE) ) );
*bm_index( bm, i * 8, y ) |= ( (potrace_word) b )
<< ( 8 * ( BM_WORDSIZE - 1 - ( i % BM_WORDSIZE ) ) );
}
}
@ -338,33 +357,35 @@ static int bm_readbody_pnm( FILE* f, double threshold, potrace_bitmap_t** bmp, i
max = readnum( f );
if( max<1 )
if( max < 1 )
{
goto format_error;
}
b = fgetc( f ); /* read single white-space character after max */
if( b==EOF )
if( b == EOF )
{
goto format_error;
}
for( y = h - 1; y>=0; y-- )
for( y = 0; y < h; y++ )
{
for( x = 0; x<w; x++ )
realheight = y + 1;
for( x = 0; x < w; x++ )
{
b = fgetc( f );
if( b==EOF )
if( b == EOF )
goto eof;
if( max>=256 )
if( max >= 256 )
{
b <<= 8;
b1 = fgetc( f );
if( b1==EOF )
if( b1 == EOF )
goto eof;
b |= b1;
@ -381,39 +402,41 @@ static int bm_readbody_pnm( FILE* f, double threshold, potrace_bitmap_t** bmp, i
max = readnum( f );
if( max<1 )
if( max < 1 )
{
goto format_error;
}
b = fgetc( f ); /* read single white-space character after max */
if( b==EOF )
if( b == EOF )
{
goto format_error;
}
for( y = h - 1; y>=0; y-- )
for( y = 0; y < h; y++ )
{
for( x = 0; x<w; x++ )
realheight = y + 1;
for( x = 0; x < w; x++ )
{
sum = 0;
for( i = 0; i<3; i++ )
for( i = 0; i < 3; i++ )
{
b = fgetc( f );
if( b==EOF )
if( b == EOF )
{
goto eof;
}
if( max>=256 )
if( max >= 256 )
{
b <<= 8;
b1 = fgetc( f );
if( b1==EOF )
if( b1 == EOF )
goto eof;
b |= b1;
@ -429,10 +452,13 @@ static int bm_readbody_pnm( FILE* f, double threshold, potrace_bitmap_t** bmp, i
break;
}
bm_flip( bm );
*bmp = bm;
return 0;
eof:
TRY_STD( bm_resize( bm, realheight ) );
bm_flip( bm );
*bmp = bm;
return 1;
@ -453,6 +479,10 @@ format_error:
}
return -2;
std_error:
bm_free( bm );
return -1;
}
@ -465,22 +495,22 @@ struct bmp_info_s
unsigned int reserved;
unsigned int DataOffset;
unsigned int InfoSize;
unsigned int w; /* width */
unsigned int h; /* height */
unsigned int w; /* width */
unsigned int h; /* height */
unsigned int Planes;
unsigned int bits; /* bits per sample */
unsigned int comp; /* compression mode */
unsigned int bits; /* bits per sample */
unsigned int comp; /* compression mode */
unsigned int ImageSize;
unsigned int XpixelsPerM;
unsigned int YpixelsPerM;
unsigned int ncolors; /* number of colors in palette */
unsigned int ncolors; /* number of colors in palette */
unsigned int ColorsImportant;
unsigned int RedMask;
unsigned int GreenMask;
unsigned int BlueMask;
unsigned int AlphaMask;
unsigned int ctbits; /* sample size for color table */
int topdown; /* top-down mode? */
unsigned int ctbits; /* sample size for color table */
int topdown; /* top-down mode? */
};
typedef struct bmp_info_s bmp_info_t;
@ -497,16 +527,16 @@ static int bmp_readint( FILE* f, int n, unsigned int* p )
unsigned int sum = 0;
int b;
for( i = 0; i<n; i++ )
for( i = 0; i < n; i++ )
{
b = fgetc( f );
if( b==EOF )
if( b == EOF )
{
return 1;
}
sum += b << (8 * i);
sum += (unsigned) b << ( 8 * i );
}
bmp_count += n;
@ -529,13 +559,13 @@ static int bmp_pad( FILE* f )
{
int c, i, b;
c = (-bmp_count) & 3;
c = ( -bmp_count ) & 3;
for( i = 0; i<c; i++ )
for( i = 0; i < c; i++ )
{
b = fgetc( f );
if( b==EOF )
if( b == EOF )
{
return 1;
}
@ -556,7 +586,7 @@ static int bmp_forward( FILE* f, int pos )
{
b = fgetc( f );
if( b==EOF )
if( b == EOF )
{
return 1;
}
@ -569,16 +599,8 @@ static int bmp_forward( FILE* f, int pos )
}
#define TRY( x ) if( x ) \
goto try_error
#define TRY_EOF( x ) if( x ) \
goto eof
/* correct y-coordinate for top-down format */
#define ycorr( y ) (bmpinfo.topdown ? bmpinfo.h - 1 - y : y)
/* safe colortable access */
#define COLTABLE( c ) ( (c) < bmpinfo.ncolors ? coltable[(c)] : 0 )
#define COLTABLE( c ) ( ( c ) < bmpinfo.ncolors ? coltable[( c )] : 0 )
/* read BMP stream after magic number. Return values as for bm_read.
* We choose to be as permissive as possible, since there are many
@ -601,6 +623,8 @@ static int bm_readbody_bmp( FILE* f, double threshold, potrace_bitmap_t** bmp )
unsigned int n;
unsigned int redshift, greenshift, blueshift;
int col1[2];
int realheight; /* in case of incomplete file, keeps track of how
* many scan lines actually contain data */
bm_read_error = NULL;
bm = NULL;
@ -616,8 +640,8 @@ static int bm_readbody_bmp( FILE* f, double threshold, potrace_bitmap_t** bmp )
/* info header */
TRY( bmp_readint( f, 4, &bmpinfo.InfoSize ) );
if( bmpinfo.InfoSize == 40 || bmpinfo.InfoSize == 64
|| bmpinfo.InfoSize == 108 || bmpinfo.InfoSize == 124 )
if( bmpinfo.InfoSize == 40 || bmpinfo.InfoSize == 64 || bmpinfo.InfoSize == 108
|| bmpinfo.InfoSize == 124 )
{
/* Windows or new OS/2 format */
bmpinfo.ctbits = 32; /* sample size in color table */
@ -632,8 +656,9 @@ static int bm_readbody_bmp( FILE* f, double threshold, potrace_bitmap_t** bmp )
TRY( bmp_readint( f, 4, &bmpinfo.ncolors ) );
TRY( bmp_readint( f, 4, &bmpinfo.ColorsImportant ) );
if( bmpinfo.InfoSize >= 108 ) /* V4 and V5 bitmaps */
if( bmpinfo.InfoSize >= 108 )
{
/* V4 and V5 bitmaps */
TRY( bmp_readint( f, 4, &bmpinfo.RedMask ) );
TRY( bmp_readint( f, 4, &bmpinfo.GreenMask ) );
TRY( bmp_readint( f, 4, &bmpinfo.BlueMask ) );
@ -647,7 +672,7 @@ static int bm_readbody_bmp( FILE* f, double threshold, potrace_bitmap_t** bmp )
if( bmpinfo.h > 0x7fffffff )
{
bmpinfo.h = (-bmpinfo.h) & 0xffffffff;
bmpinfo.h = ( -bmpinfo.h ) & 0xffffffff;
bmpinfo.topdown = 1;
}
else
@ -697,7 +722,7 @@ static int bm_readbody_bmp( FILE* f, double threshold, potrace_bitmap_t** bmp )
goto format_error; /* can't handle planes */
}
if( bmpinfo.ncolors == 0 )
if( bmpinfo.ncolors == 0 && bmpinfo.bits <= 8 )
{
bmpinfo.ncolors = 1 << bmpinfo.bits;
}
@ -705,7 +730,7 @@ static int bm_readbody_bmp( FILE* f, double threshold, potrace_bitmap_t** bmp )
/* color table, present only if bmpinfo.bits <= 8. */
if( bmpinfo.bits <= 8 )
{
coltable = (int*) calloc( bmpinfo.ncolors, sizeof(int) );
coltable = (int*) calloc( bmpinfo.ncolors, sizeof( int ) );
if( !coltable )
{
@ -714,13 +739,13 @@ static int bm_readbody_bmp( FILE* f, double threshold, potrace_bitmap_t** bmp )
/* NOTE: since we are reading a bitmap, we can immediately convert
* the color table entries to bits. */
for( i = 0; i<bmpinfo.ncolors; i++ )
for( i = 0; i < bmpinfo.ncolors; i++ )
{
TRY( bmp_readint( f, bmpinfo.ctbits / 8, &c ) );
c = ( (c >> 16) & 0xff ) + ( (c >> 8) & 0xff ) + (c & 0xff);
coltable[i] = (c > 3 * threshold * 255 ? 0 : 1);
c = ( ( c >> 16 ) & 0xff ) + ( ( c >> 8 ) & 0xff ) + ( c & 0xff );
coltable[i] = ( c > 3 * threshold * 255 ? 0 : 1 );
if( i<2 )
if( i < 2 )
{
col1[i] = c;
}
@ -728,8 +753,9 @@ static int bm_readbody_bmp( FILE* f, double threshold, potrace_bitmap_t** bmp )
}
/* forward to data */
if( bmpinfo.InfoSize != 12 ) /* not old OS/2 format */
if( bmpinfo.InfoSize != 12 )
{
/* not old OS/2 format */
TRY( bmp_forward( f, bmpinfo.DataOffset ) );
}
@ -741,19 +767,18 @@ static int bm_readbody_bmp( FILE* f, double threshold, potrace_bitmap_t** bmp )
goto std_error;
}
/* zero it out */
bm_clear( bm, 0 );
realheight = 0;
switch( bmpinfo.bits + 0x100 * bmpinfo.comp )
{
default:
goto format_error;
break;
goto format_error; break;
case 0x001: /* monochrome palette */
case 0x001: /* monochrome palette */
if( col1[0] < col1[1] ) /* make the darker color black */
if( col1[0] < col1[1] )
{
/* make the darker color black */
mask = 0xff;
}
else
@ -762,17 +787,17 @@ static int bm_readbody_bmp( FILE* f, double threshold, potrace_bitmap_t** bmp )
}
/* raster data */
for( y = 0; y<bmpinfo.h; y++ )
for( y = 0; y < bmpinfo.h; y++ )
{
realheight = y + 1;
bmp_pad_reset();
for( i = 0; 8 * i<bmpinfo.w; i++ )
for( i = 0; 8 * i < bmpinfo.w; i++ )
{
TRY_EOF( bmp_readint( f, 1, &b ) );
b ^= mask;
*bm_index( bm, i * 8,
ycorr( y ) ) |= ( (potrace_word) b ) <<
( 8 * ( BM_WORDSIZE - 1 - (i % BM_WORDSIZE) ) );
*bm_index( bm, i * 8, y ) |= ( (potrace_word) b )
<< ( 8 * ( BM_WORDSIZE - 1 - ( i % BM_WORDSIZE ) ) );
}
TRY( bmp_pad( f ) );
@ -788,25 +813,26 @@ static int bm_readbody_bmp( FILE* f, double threshold, potrace_bitmap_t** bmp )
case 0x007:
case 0x008:
for( y = 0; y<bmpinfo.h; y++ )
for( y = 0; y < bmpinfo.h; y++ )
{
realheight = y + 1;
bmp_pad_reset();
bitbuf = 0; /* bit buffer: bits in buffer are high-aligned */
n = 0; /* number of bits currently in bitbuffer */
for( x = 0; x<bmpinfo.w; x++ )
for( x = 0; x < bmpinfo.w; x++ )
{
if( n < bmpinfo.bits )
{
TRY_EOF( bmp_readint( f, 1, &b ) );
bitbuf |= b << (INTBITS - 8 - n);
bitbuf |= b << ( INTBITS - 8 - n );
n += 8;
}
b = bitbuf >> (INTBITS - bmpinfo.bits);
b = bitbuf >> ( INTBITS - bmpinfo.bits );
bitbuf <<= bmpinfo.bits;
n -= bmpinfo.bits;
BM_UPUT( bm, x, ycorr( y ), COLTABLE( b ) );
BM_UPUT( bm, x, y, COLTABLE( b ) );
}
TRY( bmp_pad( f ) );
@ -824,15 +850,16 @@ static int bm_readbody_bmp( FILE* f, double threshold, potrace_bitmap_t** bmp )
case 0x018: /* 24-bit encoding */
case 0x020: /* 32-bit encoding */
for( y = 0; y<bmpinfo.h; y++ )
for( y = 0; y < bmpinfo.h; y++ )
{
realheight = y + 1;
bmp_pad_reset();
for( x = 0; x<bmpinfo.w; x++ )
for( x = 0; x < bmpinfo.w; x++ )
{
TRY_EOF( bmp_readint( f, bmpinfo.bits / 8, &c ) );
c = ( (c >> 16) & 0xff ) + ( (c >> 8) & 0xff ) + (c & 0xff);
BM_UPUT( bm, x, ycorr( y ), c > 3 * threshold * 255 ? 0 : 1 );
c = ( ( c >> 16 ) & 0xff ) + ( ( c >> 8 ) & 0xff ) + ( c & 0xff );
BM_UPUT( bm, x, y, c > 3 * threshold * 255 ? 0 : 1 );
}
TRY( bmp_pad( f ) );
@ -841,21 +868,28 @@ static int bm_readbody_bmp( FILE* f, double threshold, potrace_bitmap_t** bmp )
break;
case 0x320: /* 32-bit encoding with bitfields */
if( bmpinfo.RedMask == 0 || bmpinfo.GreenMask == 0 || bmpinfo.BlueMask == 0 )
{
goto format_error;
}
redshift = lobit( bmpinfo.RedMask );
greenshift = lobit( bmpinfo.GreenMask );
blueshift = lobit( bmpinfo.BlueMask );
for( y = 0; y<bmpinfo.h; y++ )
for( y = 0; y < bmpinfo.h; y++ )
{
realheight = y + 1;
bmp_pad_reset();
for( x = 0; x<bmpinfo.w; x++ )
for( x = 0; x < bmpinfo.w; x++ )
{
TRY_EOF( bmp_readint( f, bmpinfo.bits / 8, &c ) );
c = ( (c & bmpinfo.RedMask) >> redshift ) +
( (c & bmpinfo.GreenMask) >> greenshift ) +
( (c & bmpinfo.BlueMask) >> blueshift );
BM_UPUT( bm, x, ycorr( y ), c > 3 * threshold * 255 ? 0 : 1 );
c = ( ( c & bmpinfo.RedMask ) >> redshift )
+ ( ( c & bmpinfo.GreenMask ) >> greenshift )
+ ( ( c & bmpinfo.BlueMask ) >> blueshift );
BM_UPUT( bm, x, y, c > 3 * threshold * 255 ? 0 : 1 );
}
TRY( bmp_pad( f ) );
@ -872,26 +906,27 @@ static int bm_readbody_bmp( FILE* f, double threshold, potrace_bitmap_t** bmp )
TRY_EOF( bmp_readint( f, 1, &b ) ); /* opcode */
TRY_EOF( bmp_readint( f, 1, &c ) ); /* argument */
if( b>0 )
if( b > 0 )
{
/* repeat count */
col[0] = COLTABLE( (c >> 4) & 0xf );
col[0] = COLTABLE( ( c >> 4 ) & 0xf );
col[1] = COLTABLE( c & 0xf );
for( i = 0; i<b && x<bmpinfo.w; i++ )
for( i = 0; i < b && x < bmpinfo.w; i++ )
{
if( x>=bmpinfo.w )
if( x >= bmpinfo.w )
{
x = 0;
y++;
}
if( y>=bmpinfo.h )
if( x >= bmpinfo.w || y >= bmpinfo.h )
{
break;
}
BM_UPUT( bm, x, ycorr( y ), col[i & 1] );
realheight = y + 1;
BM_PUT( bm, x, y, col[i & 1] );
x++;
}
}
@ -917,29 +952,30 @@ static int bm_readbody_bmp( FILE* f, double threshold, potrace_bitmap_t** bmp )
else
{
/* verbatim segment */
for( i = 0; i<c; i++ )
for( i = 0; i < c; i++ )
{
if( (i & 1)==0 )
if( ( i & 1 ) == 0 )
{
TRY_EOF( bmp_readint( f, 1, &b ) );
}
if( x>=bmpinfo.w )
if( x >= bmpinfo.w )
{
x = 0;
y++;
}
if( y>=bmpinfo.h )
if( x >= bmpinfo.w || y >= bmpinfo.h )
{
break;
}
BM_PUT( bm, x, ycorr( y ), COLTABLE( ( b >> ( 4 - 4 * (i & 1) ) ) & 0xf ) );
realheight = y + 1;
BM_PUT( bm, x, y, COLTABLE( ( b >> ( 4 - 4 * ( i & 1 ) ) ) & 0xf ) );
x++;
}
if( (c + 1) & 2 )
if( ( c + 1 ) & 2 )
{
/* pad to 16-bit boundary */
TRY_EOF( bmp_readint( f, 1, &b ) );
@ -958,23 +994,24 @@ static int bm_readbody_bmp( FILE* f, double threshold, potrace_bitmap_t** bmp )
TRY_EOF( bmp_readint( f, 1, &b ) ); /* opcode */
TRY_EOF( bmp_readint( f, 1, &c ) ); /* argument */
if( b>0 )
if( b > 0 )
{
/* repeat count */
for( i = 0; i<b; i++ )
for( i = 0; i < b; i++ )
{
if( x>=bmpinfo.w )
if( x >= bmpinfo.w )
{
x = 0;
y++;
}
if( y>=bmpinfo.h )
if( x >= bmpinfo.w || y >= bmpinfo.h )
{
break;
}
BM_UPUT( bm, x, ycorr( y ), COLTABLE( c ) );
realheight = y + 1;
BM_PUT( bm, x, y, COLTABLE( c ) );
x++;
}
}
@ -1000,22 +1037,23 @@ static int bm_readbody_bmp( FILE* f, double threshold, potrace_bitmap_t** bmp )
else
{
/* verbatim segment */
for( i = 0; i<c; i++ )
for( i = 0; i < c; i++ )
{
TRY_EOF( bmp_readint( f, 1, &b ) );
if( x>=bmpinfo.w )
if( x >= bmpinfo.w )
{
x = 0;
y++;
}
if( y>=bmpinfo.h )
if( x >= bmpinfo.w || y >= bmpinfo.h )
{
break;
}
BM_PUT( bm, x, ycorr( y ), COLTABLE( b ) );
realheight = y + 1;
BM_PUT( bm, x, y, COLTABLE( b ) );
x++;
}
@ -1035,11 +1073,24 @@ static int bm_readbody_bmp( FILE* f, double threshold, potrace_bitmap_t** bmp )
bmp_forward( f, bmpinfo.FileSize );
free( coltable );
if( bmpinfo.topdown )
{
bm_flip( bm );
}
*bmp = bm;
return 0;
eof:
TRY_STD( bm_resize( bm, realheight ) );
free( coltable );
if( bmpinfo.topdown )
{
bm_flip( bm );
}
*bmp = bm;
return 1;
@ -1072,17 +1123,16 @@ void bm_writepbm( FILE* f, potrace_bitmap_t* bm )
w = bm->w;
h = bm->h;
bpr = (w + 7) / 8;
bpr = ( w + 7 ) / 8;
fprintf( f, "P4\n%d %d\n", w, h );
for( y = h - 1; y>=0; y-- )
for( y = h - 1; y >= 0; y-- )
{
for( i = 0; i<bpr; i++ )
for( i = 0; i < bpr; i++ )
{
c =
( *bm_index( bm, i * 8,
y ) >> ( 8 * ( BM_WORDSIZE - 1 - (i % BM_WORDSIZE) ) ) ) & 0xff;
c = ( *bm_index( bm, i * 8, y ) >> ( 8 * ( BM_WORDSIZE - 1 - ( i % BM_WORDSIZE ) ) ) )
& 0xff;
fputc( c, f );
}
}
@ -1101,17 +1151,17 @@ int bm_print( FILE* f, potrace_bitmap_t* bm )
int sw, sh;
sw = bm->w < 79 ? bm->w : 79;
sh = bm->w < 79 ? bm->h : bm->h * sw * 44 / (79 * bm->w);
sh = bm->w < 79 ? bm->h : bm->h * sw * 44 / ( 79 * bm->w );
for( yy = sh - 1; yy>=0; yy-- )
for( yy = sh - 1; yy >= 0; yy-- )
{
for( xx = 0; xx<sw; xx++ )
for( xx = 0; xx < sw; xx++ )
{
d = 0;
for( x = xx * bm->w / sw; x<(xx + 1) * bm->w / sw; x++ )
for( x = xx * bm->w / sw; x < ( xx + 1 ) * bm->w / sw; x++ )
{
for( y = yy * bm->h / sh; y<(yy + 1) * bm->h / sh; y++ )
for( y = yy * bm->h / sh; y < ( yy + 1 ) * bm->h / sh; y++ )
{
if( BM_GET( bm, x, y ) )
{

4
potrace/bitmap_io.h
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2001-2015 Peter Selinger.
/* Copyright (C) 2001-2017 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. */
@ -7,8 +7,8 @@
#ifndef BITMAP_IO_H
#define BITMAP_IO_H
#include <stdio.h>
#include "bitmap.h"
#include <stdio.h>
/* Note that bitmaps are stored bottom to top, i.e., the first
* scanline is the bottom-most one */

33
potrace/bitops.h
View File

@ -1,8 +1,7 @@
/* Copyright (C) 2001-2015 Peter Selinger.
/* Copyright (C) 2001-2017 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. */
/* bits.h: this file defines some macros for bit manipulations. We
* provide a generic implementation, as well as machine- and
* compiler-specific fast implementations */
@ -22,19 +21,19 @@
/* ---------------------------------------------------------------------- */
/* machine specific macros */
#if defined(HAVE_I386)
#if defined( HAVE_I386 )
static inline unsigned int lobit( unsigned int x )
{
unsigned int res;
asm ("bsf %1,%0\n\t"
"jnz 0f\n\t"
"movl $32,%0\n"
"0:"
: "=r" (res)
: "r" (x)
: "cc");
asm ( "bsf %1,%0\n\t"
"jnz 0f\n\t"
"movl $32,%0\n"
"0:"
: "=r" ( res )
: "r" ( x )
: "cc" );
return res;
}
@ -43,13 +42,13 @@ static inline unsigned int hibit( unsigned int x )
{
unsigned int res;
asm ("bsr %1,%0\n\t"
"jnz 0f\n\t"
"movl $-1,%0\n"
"0:"
: "=r" (res)
: "r" (x)
: "cc");
asm ( "bsr %1,%0\n\t"
"jnz 0f\n\t"
"movl $-1,%0\n"
"0:"
: "=r" ( res )
: "r" ( x )
: "cc" );
return res + 1;
}

16
potrace/curve.cpp
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2001-2015 Peter Selinger.
/* Copyright (C) 2001-2017 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. */
@ -12,12 +12,12 @@
#include <stdlib.h>
#include <string.h>
#include "potracelib.h"
#include "lists.h"
#include "curve.h"
#include "lists.h"
#include "potracelib.h"
#define SAFE_CALLOC( var, n, typ ) \
if( ( var = (typ*) calloc( n, sizeof(typ) ) ) == NULL ) \
#define SAFE_CALLOC( var, n, typ ) \
if( ( var = (typ*) calloc( n, sizeof( typ ) ) ) == NULL ) \
goto calloc_error
/* ---------------------------------------------------------------------- */
@ -29,9 +29,9 @@ path_t* path_new( void )
privpath_t* priv = NULL;
SAFE_CALLOC( p, 1, path_t );
memset( p, 0, sizeof(path_t) );
memset( p, 0, sizeof( path_t ) );
SAFE_CALLOC( priv, 1, privpath_t );
memset( priv, 0, sizeof(privpath_t) );
memset( priv, 0, sizeof( privpath_t ) );
p->priv = priv;
return p;
@ -97,7 +97,7 @@ typedef dpoint_t dpoint3_t[3];
* Return 0 on success, 1 on error with errno set. */
int privcurve_init( privcurve_t* curve, int n )
{
memset( curve, 0, sizeof(privcurve_t) );
memset( curve, 0, sizeof( privcurve_t ) );
curve->n = n;
SAFE_CALLOC( curve->tag, n, int );
SAFE_CALLOC( curve->c, n, dpoint3_t );

2
potrace/curve.h
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2001-2015 Peter Selinger.
/* Copyright (C) 2001-2017 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. */

119
potrace/decompose.cpp
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2001-2015 Peter Selinger.
/* Copyright (C) 2001-2017 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. */
@ -6,16 +6,21 @@
#include <config.h>
#endif
#include <cstdint>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#ifdef HAVE_INTTYPES_H
#include <inttypes.h>
#endif
#include "potracelib.h"
#include "curve.h"
#include "lists.h"
#include "bitmap.h"
#include "curve.h"
#include "decompose.h"
#include "lists.h"
#include "potracelib.h"
#include "progress.h"
/* ---------------------------------------------------------------------- */
@ -28,23 +33,22 @@ static inline int detrand( int x, int y )
{
/* 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,
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];
z = ( ( 0x04b3e375 * x ) ^ y ) * 0x05a8ef93;
z = t[z & 0xff] ^ t[( z >> 8 ) & 0xff] ^ t[( z >> 16 ) & 0xff] ^ t[( z >> 24 ) & 0xff];
return z;
}
@ -60,9 +64,9 @@ static void bm_clearexcess( potrace_bitmap_t* bm )
if( bm->w % BM_WORDBITS != 0 )
{
mask = BM_ALLBITS << ( BM_WORDBITS - (bm->w % BM_WORDBITS) );
mask = BM_ALLBITS << ( BM_WORDBITS - ( bm->w % BM_WORDBITS ) );
for( y = 0; y<bm->h; y++ )
for( y = 0; y < bm->h; y++ )
{
*bm_index( bm, bm->w, y ) &= mask;
}
@ -80,13 +84,13 @@ typedef struct bbox_s bbox_t;
* 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 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( y = bbox->y0; y < bbox->y1; y++ )
{
for( i = imin; i<imax; i++ )
for( i = imin; i < imax; i++ )
{
bm_scanline( bm, y )[i] = 0;
}
@ -103,11 +107,12 @@ 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 */
for( i = 2; i < 5; i++ )
{
/* check at "radius" i */
ct = 0;
for( a = -i + 1; a<=i - 1; a++ )
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;
@ -115,11 +120,11 @@ static int majority( potrace_bitmap_t* bm, int x, int y )
ct += BM_GET( bm, x - i, y + a ) ? 1 : -1;
}
if( ct>0 )
if( ct > 0 )
{
return 1;
}
else if( ct<0 )
else if( ct < 0 )
{
return 0;
}
@ -137,10 +142,10 @@ static int majority( potrace_bitmap_t* bm, int x, int y )
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 xlo = x & ( BM_WORDBITS - 1 ); /* = x % BM_WORDBITS */
int i;
if( xhi<xa )
if( xhi < xa )
{
for( i = xhi; i < xa; i += BM_WORDBITS )
{
@ -159,7 +164,7 @@ static void xor_to_ref( potrace_bitmap_t* bm, int x, int y, int xa )
* a<<(b&31). I spent hours looking for this bug. */
if( xlo )
{
*bm_index( bm, xhi, y ) ^= ( BM_ALLBITS << (BM_WORDBITS - xlo) );
*bm_index( bm, xhi, y ) ^= ( BM_ALLBITS << ( BM_WORDBITS - xlo ) );
}
}
@ -176,8 +181,9 @@ 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 */
if( p->priv->len <= 0 )
{
/* a path of length 0 is silly, but legal */
return;
}
@ -185,7 +191,7 @@ static void xor_path( potrace_bitmap_t* bm, path_t* p )
xa = p->priv->pt[0].x & - BM_WORDBITS;
for( k = 0; k<p->priv->len; k++ )
for( k = 0; k < p->priv->len; k++ )
{
x = p->priv->pt[k].x;
y = p->priv->pt[k].y;
@ -212,7 +218,7 @@ static void setbbox_path( bbox_t* bbox, path_t* p )
bbox->x0 = INT_MAX;
bbox->x1 = 0;
for( k = 0; k<p->priv->len; k++ )
for( k = 0; k < p->priv->len; k++ )
{
x = p->priv->pt[k].x;
y = p->priv->pt[k].y;
@ -248,7 +254,8 @@ static void setbbox_path( bbox_t* bbox, path_t* p )
* 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 x, y, dirx, diry, len, size;
uint64_t area;
int c, d, tmp;
point_t* pt, * pt1;
path_t* p = NULL;
@ -265,11 +272,11 @@ static path_t* findpath( potrace_bitmap_t* bm, int x0, int y0, int sign, int tur
while( 1 )
{
/* add point to path */
if( len>=size )
if( len >= size )
{
size += 100;
size = (int) (1.3 * size);
pt1 = (point_t*) realloc( pt, size * sizeof(point_t) );
size = (int) ( 1.3 * size );
pt1 = (point_t*) realloc( pt, size * sizeof( point_t ) );
if( !pt1 )
{
@ -289,20 +296,21 @@ static path_t* findpath( potrace_bitmap_t* bm, int x0, int y0, int sign, int tur
area += x * diry;
/* path complete? */
if( x==x0 && y==y0 )
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 );
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( c && !d )
{
/* ambiguous turn */
if( turnpolicy == POTRACE_TURNPOLICY_RIGHT
|| (turnpolicy == POTRACE_TURNPOLICY_BLACK && sign == '+')
|| (turnpolicy == POTRACE_TURNPOLICY_WHITE && sign == '-')
|| ( 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 ) ) )
@ -318,14 +326,16 @@ static path_t* findpath( potrace_bitmap_t* bm, int x0, int y0, int sign, int tur
diry = tmp;
}
}
else if( c ) /* right turn */
else if( c )
{
/* right turn */
tmp = dirx;
dirx = diry;
diry = -tmp;
}
else if( !d ) /* left turn */
else if( !d )
{
/* left turn */
tmp = dirx;
dirx = -diry;
diry = tmp;
@ -342,7 +352,7 @@ static path_t* findpath( potrace_bitmap_t* bm, int x0, int y0, int sign, int tur
p->priv->pt = pt;
p->priv->len = len;
p->area = area;
p->area = area <= INT_MAX ? area : INT_MAX; /* avoid overflow */
p->sign = sign;
return p;
@ -519,11 +529,11 @@ static int findnext( potrace_bitmap_t* bm, int* xp, int* yp )
int y;
int x0;
x0 = (*xp) & ~(BM_WORDBITS - 1);
x0 = ( *xp ) & ~( BM_WORDBITS - 1 );
for( y = *yp; y>=0; y-- )
for( y = *yp; y >= 0; y-- )
{
for( x = x0; x<bm->w; x += BM_WORDBITS )
for( x = x0; x < bm->w && x >= 0; x += (unsigned) BM_WORDBITS )
{
if( *bm_index( bm, x, y ) )
{
@ -552,9 +562,7 @@ static int findnext( potrace_bitmap_t* bm, int* xp, int* yp )
* 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,
int bm_to_pathlist( const potrace_bitmap_t* bm, path_t** plistp, const potrace_param_t* param,
progress_t* progress )
{
int x;
@ -588,7 +596,7 @@ int bm_to_pathlist( const potrace_bitmap_t* bm,
/* calculate the path */
p = findpath( bm1, x, y + 1, sign, param->turnpolicy );
if( p==NULL )
if( p == NULL )
{
goto error;
}
@ -606,8 +614,9 @@ int bm_to_pathlist( const potrace_bitmap_t* bm,
list_insert_beforehook( p, plist_hook );
}
if( bm1->h > 0 ) /* to be sure */
if( bm1->h > 0 )
{
/* to be sure */
progress_update( 1 - y / (double) bm1->h, progress );
}
}

9
potrace/decompose.h
View File

@ -1,18 +1,15 @@
/* Copyright (C) 2001-2015 Peter Selinger.
/* Copyright (C) 2001-2017 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 DECOMPOSE_H
#define DECOMPOSE_H
#include "curve.h"
#include "potracelib.h"
#include "progress.h"
#include "curve.h"
int bm_to_pathlist( const potrace_bitmap_t* bm,
path_t** plistp,
const potrace_param_t* param,
int bm_to_pathlist( const potrace_bitmap_t* bm, path_t** plistp, const potrace_param_t* param,
progress_t* progress );
#endif /* DECOMPOSE_H */

505
potrace/greymap.cpp
File diff suppressed because it is too large
View File

53
potrace/greymap.h
View File

@ -1,44 +1,50 @@
/* Copyright (C) 2001-2015 Peter Selinger.
/* Copyright (C) 2001-2017 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 GREYMAP_H
#define GREYMAP_H
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
/* type for greymap samples */
typedef signed short int gm_sample_t;
/* internal format for greymaps. Note: in this format, rows are
* ordered from bottom to top. The pixels in each row are given from
* left to right. */
struct greymap_s
{
int w; /* width, in pixels */
int h; /* height, in pixels */
signed short int* map; /* raw data, w*h values */
int w; /* width, in pixels */
int h; /* height, in pixels */
int dy; /* offset between scanlines (in samples);
* can be negative */
gm_sample_t* base; /* root of allocated data */
gm_sample_t* map; /* points to the lower left pixel */
};
typedef struct greymap_s greymap_t;
/* macros for accessing pixel at index (x,y). Note that the origin is
* in the *lower* left corner. U* macros omit the bounds check. */
#define gm_index( gm, x, y ) (&(gm)->map[(x) + (y) * (ptrdiff_t) (gm)->w])
#define gm_safe( gm, x, \
y ) ( (int) (x)>=0 && (int) (x)<(gm)->w && (int) (y)>=0 \
&& (int) (y)<(gm)->h )
#define gm_bound( x, m ) ( (x)<0 ? 0 : (x)>=(m) ? (m) - 1 : (x) )
#define gm_scanline( gm, y ) ( ( gm )->map + (ptrdiff_t) ( y ) * (ptrdiff_t) ( gm )->dy )
#define gm_index( gm, x, y ) ( gm_scanline( gm, y ) + ( x ) )
#define gm_safe( gm, x, y ) \
( (int) ( x ) >= 0 && (int) ( x ) < ( gm )->w && (int) ( y ) >= 0 && (int) ( y ) < ( gm )->h )
#define gm_bound( x, m ) ( ( x ) < 0 ? 0 : ( x ) >= ( m ) ? (m) - 1 : ( x ) )
#define GM_UGET( gm, x, y ) ( *gm_index( gm, x, y ) )
#define GM_UINC( gm, x, y, b ) ( *gm_index( gm, x, y ) += (short int) (b) )
#define GM_UINC( gm, x, y, b ) ( *gm_index( gm, x, y ) += (gm_sample_t) ( b ) )
#define GM_UINV( gm, x, y ) ( *gm_index( gm, x, y ) = 255 - *gm_index( gm, x, y ) )
#define GM_UPUT( gm, x, y, b ) ( *gm_index( gm, x, y ) = (short int) (b) )
#define GM_GET( gm, x, y ) (gm_safe( gm, x, y ) ? GM_UGET( gm, x, y ) : 0)
#define GM_INC( gm, x, y, b ) (gm_safe( gm, x, y ) ? GM_UINC( gm, x, y, b ) : 0)
#define GM_INV( gm, x, y ) (gm_safe( gm, x, y ) ? GM_UINV( gm, x, y ) : 0)
#define GM_PUT( gm, x, y, b ) (gm_safe( gm, x, y ) ? GM_UPUT( gm, x, y, b ) : 0)
#define GM_BGET( gm, x, y ) GM_UGET( gm, gm_bound( x, gm->w ), gm_bound( y, gm->h ) )
#define GM_UPUT( gm, x, y, b ) ( *gm_index( gm, x, y ) = (gm_sample_t) ( b ) )
#define GM_GET( gm, x, y ) ( gm_safe( gm, x, y ) ? GM_UGET( gm, x, y ) : 0 )
#define GM_INC( gm, x, y, b ) ( gm_safe( gm, x, y ) ? GM_UINC( gm, x, y, b ) : 0 )
#define GM_INV( gm, x, y ) ( gm_safe( gm, x, y ) ? GM_UINV( gm, x, y ) : 0 )
#define GM_PUT( gm, x, y, b ) ( gm_safe( gm, x, y ) ? GM_UPUT( gm, x, y, b ) : 0 )
#define GM_BGET( gm, x, y ) \
( ( gm )->w == 0 || ( gm )->h == 0 ? 0 : GM_UGET( gm, gm_bound( x, ( gm )->w ), \
gm_bound( y, ( gm )->h ) ) )
/* modes for cutting off out-of-range values. The following names
* refer to winding numbers. I.e., make a pixel black if winding
@ -56,7 +62,12 @@ greymap_t* gm_dup( greymap_t* gm );
void gm_free( greymap_t* gm );
void gm_clear( greymap_t* gm, int b );
int gm_read( FILE* f, greymap_t** gmp );
int gm_writepgm( FILE* f, greymap_t* gm, char* comment, int raw, int mode, double gamma );
int gm_print( FILE* f, greymap_t* gm );
int gm_writepgm( FILE* f,
greymap_t* gm,
const char* comment,
int raw,
int mode,
double gamma );
int gm_print( FILE* f, greymap_t* gm );
#endif /* GREYMAP_H */

313
potrace/lists.h
View File

@ -1,8 +1,7 @@
/* Copyright (C) 2001-2015 Peter Selinger.
/* Copyright (C) 2001-2017 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 _PS_LISTS_H
#define _PS_LISTS_H
@ -31,148 +30,168 @@
* such as "if (...) macro(...); else ...". If we didn't use this obscure
* trick, we'd have to omit the ";" in such cases. */
#define MACRO_BEGIN do {
#define MACRO_END } \
#define MACRO_BEGIN \
do \
{
#define MACRO_END \
} \
while( 0 )
/* ---------------------------------------------------------------------- */
/* macros for singly-linked lists */
/* traverse list. At the end, elt is set to NULL. */
#define list_forall( elt, list ) for( elt = list; elt!=NULL; elt = elt->next )
#define list_forall( elt, list ) for( elt = list; elt != NULL; elt = elt->next )
/* set elt to the first element of list satisfying boolean condition
* c, or NULL if not found */
#define list_find( elt, list, c ) \
#define list_find( elt, list, c ) \
MACRO_BEGIN list_forall( elt, list ) if( c ) \
break; \
MACRO_END
/* like forall, except also set hook for elt. */
#define list_forall2( elt, list, hook ) \
for( elt = list, hook = &list; elt!=NULL; hook = &elt->next, elt = elt->next )
for( elt = list, hook = &list; elt != NULL; hook = &elt->next, elt = elt->next )
/* same as list_find, except also set hook for elt. */
#define list_find2( elt, list, c, hook ) \
#define list_find2( elt, list, c, hook ) \
MACRO_BEGIN list_forall2( elt, list, hook ) if( c ) \
break; \
MACRO_END
/* same, except only use hook. */
#define _list_forall_hook( list, hook ) \
for( hook = &list; *hook!=NULL; hook = &(*hook)->next )
#define _list_forall_hook( list, hook ) for( hook = &list; *hook != NULL; hook = &( *hook )->next )
/* same, except only use hook. Note: c may only refer to *hook, not elt. */
#define _list_find_hook( list, c, hook ) \
#define _list_find_hook( list, c, hook ) \
MACRO_BEGIN _list_forall_hook( list, hook ) if( c ) \
break; \
MACRO_END
/* insert element after hook */
#define list_insert_athook( elt, hook ) \
MACRO_BEGIN elt->next = *hook; *hook = elt; MACRO_END
MACRO_BEGIN elt->next = *hook; \
*hook = elt; \
MACRO_END
/* insert element before hook */
#define list_insert_beforehook( elt, hook ) \
MACRO_BEGIN elt->next = *hook; *hook = elt; hook = &elt->next; MACRO_END
MACRO_BEGIN elt->next = *hook; \
*hook = elt; \
hook = &elt->next; \
MACRO_END
/* unlink element after hook, let elt be unlinked element, or NULL.
* hook remains. */
#define list_unlink_athook( list, elt, hook ) \
MACRO_BEGIN \
elt = hook ? *hook : NULL; if( elt ) { *hook = elt->next; elt->next = NULL; } \
MACRO_BEGIN \
elt = hook ? *hook : NULL; \
if( elt ) \
{ \
*hook = elt->next; \
elt->next = NULL; \
} \
MACRO_END
/* unlink the specific element, if it is in the list. Otherwise, set
* elt to NULL */
#define list_unlink( listtype, list, elt ) \
MACRO_BEGIN \
listtype * *_hook; \
_list_find_hook( list, *_hook==elt, _hook ); \
list_unlink_athook( list, elt, _hook ); \
#define list_unlink( listtype, list, elt ) \
MACRO_BEGIN \
listtype * *_hook; \
_list_find_hook( list, *_hook == elt, _hook ); \
list_unlink_athook( list, elt, _hook ); \
MACRO_END
/* prepend elt to list */
#define list_prepend( list, elt ) \
MACRO_BEGIN elt->next = list; list = elt; MACRO_END
MACRO_BEGIN elt->next = list; \
list = elt; \
MACRO_END
/* append elt to list. */
#define list_append( listtype, list, elt ) \
MACRO_BEGIN \
listtype * *_hook; \
_list_forall_hook( list, _hook ) {} \
list_insert_athook( elt, _hook ); \
#define list_append( listtype, list, elt ) \
MACRO_BEGIN \
listtype * *_hook; \
_list_forall_hook( list, _hook ) \
{ \
} \
list_insert_athook( elt, _hook ); \
MACRO_END
/* unlink the first element that satisfies the condition. */
#define list_unlink_cond( listtype, list, elt, c ) \
MACRO_BEGIN \
listtype * *_hook; \
list_find2( elt, list, c, _hook ); \
list_unlink_athook( list, elt, _hook ); \
#define list_unlink_cond( listtype, list, elt, c ) \
MACRO_BEGIN \
listtype * *_hook; \
list_find2( elt, list, c, _hook ); \
list_unlink_athook( list, elt, _hook ); \
MACRO_END
/* let elt be the nth element of the list, starting to count from 0.
* Return NULL if out of bounds. */
#define list_nth( elt, list, n ) \
MACRO_BEGIN \
int _x; /* only evaluate n once */ \
for( _x = (n), elt = list; _x && elt; _x--, elt = elt->next ) {} \
#define list_nth( elt, list, n ) \
MACRO_BEGIN \
int _x; /* only evaluate n once */ \
for( _x = ( n ), elt = list; _x && elt; _x--, elt = elt->next ) \
{ \
} \
MACRO_END
/* let elt be the nth element of the list, starting to count from 0.
* Return NULL if out of bounds. */
#define list_nth_hook( elt, list, n, hook ) \
MACRO_BEGIN \
int _x; /* only evaluate n once */ \
for( _x = (n), elt = list, hook = &list; _x && elt; \
_x--, hook = &elt->next, elt = elt->next ) {} \
#define list_nth_hook( elt, list, n, hook ) \
MACRO_BEGIN \
int _x; /* only evaluate n once */ \
for( _x = ( n ), elt = list, hook = &list; _x && elt; \
_x--, hook = &elt->next, elt = elt->next ) \
{ \
} \
MACRO_END
/* set n to the length of the list */
#define list_length( listtype, list, n ) \
MACRO_BEGIN \
listtype * _elt; \
n = 0; \
list_forall( _elt, list ) \
n++; \
#define list_length( listtype, list, n ) \
MACRO_BEGIN \
listtype * _elt; \
n = 0; \
list_forall( _elt, list ) n++; \
MACRO_END
/* set n to the index of the first element satisfying cond, or -1 if
* none found. Also set elt to the element, or NULL if none found. */
#define list_index( list, n, elt, c ) \
MACRO_BEGIN \
n = 0; \
list_forall( elt, list ) { \
if( c ) \
#define list_index( list, n, elt, c ) \
MACRO_BEGIN \
n = 0; \
list_forall( elt, list ) \
{ \
if( c ) \
break; \
n++; \
} \
if( !elt ) \
n = -1; \
n++; \
} \
if( !elt ) \
n = -1; \
MACRO_END
/* set n to the number of elements in the list that satisfy condition c */
#define list_count( list, n, elt, c ) \
MACRO_BEGIN \
n = 0; \
list_forall( elt, list ) { \
if( c ) \
#define list_count( list, n, elt, c ) \
MACRO_BEGIN \
n = 0; \
list_forall( elt, list ) \
{ \
if( c ) \
n++; \
} \
} \
MACRO_END
/* let elt be each element of the list, unlinked. At the end, set list=NULL. */
#define list_forall_unlink( elt, list ) \
for( elt = list; elt ? (list = elt->next, elt->next = NULL), 1 : 0; elt = list )
for( elt = list; elt ? ( list = elt->next, elt->next = NULL ), 1 : 0; elt = list )
/* reverse a list (efficient) */
#define list_reverse( listtype, list ) \
MACRO_BEGIN \
listtype * _list1 = NULL, *elt; \
list_forall_unlink( elt, list ) \
list_prepend( _list1, elt ); \
list = _list1; \
#define list_reverse( listtype, list ) \
MACRO_BEGIN \
listtype * _list1 = NULL, *elt; \
list_forall_unlink( elt, list ) list_prepend( _list1, elt ); \
list = _list1; \
MACRO_END
/* insert the element ELT just before the first element TMP of the
@ -186,10 +205,10 @@
* Note: it is much more efficient to construct a list with
* list_prepend and then order it with list_merge_sort, than to
* construct it with list_insert_ordered. */
#define list_insert_ordered( listtype, list, elt, tmp, cond ) \
MACRO_BEGIN \
listtype * *_hook; \
_list_find_hook( list, ( tmp = *_hook, (cond) ), _hook ); \
#define list_insert_ordered( listtype, list, elt, tmp, cond ) \
MACRO_BEGIN \
listtype * *_hook; \
_list_find_hook( list, ( tmp = *_hook, ( cond ) ), _hook ); \
list_insert_athook( elt, _hook ); \
MACRO_END
@ -200,12 +219,11 @@
* "less than" condition, each segment of equal elements will retain
* the original order. The latter is slower but sometimes
* prettier. Average running time: n*n/2. */
#define list_sort( listtype, list, a, b, cond ) \
MACRO_BEGIN \
listtype * _newlist = NULL; \
list_forall_unlink( a, list ) \
list_insert_ordered( listtype, _newlist, a, b, cond ); \
list = _newlist; \
#define list_sort( listtype, list, a, b, cond ) \
MACRO_BEGIN \
listtype * _newlist = NULL; \
list_forall_unlink( a, list ) list_insert_ordered( listtype, _newlist, a, b, cond ); \
list = _newlist; \
MACRO_END
/* a much faster sort algorithm (merge sort, n log n worst case). It
@ -213,90 +231,103 @@
* component. Note there is no curious reversal of order of equal
* elements as for list_sort. */
#define list_mergesort( listtype, list, a, b, cond ) \
MACRO_BEGIN \
listtype * _elt, **_hook1; \
\
for( _elt = list; _elt; _elt = _elt->next1 ) { \
_elt->next1 = _elt->next; \
_elt->next = NULL; \
} \
do { \
_hook1 = &(list); \
while( (a = *_hook1) != NULL && (b = a->next1) != NULL ) { \
_elt = b->next1; \
_list_merge_cond( listtype, a, b, cond, *_hook1 ); \
_hook1 = &( (*_hook1)->next1 ); \
*_hook1 = _elt; \
} \
#define list_mergesort( listtype, list, a, b, cond ) \
MACRO_BEGIN \
listtype * _elt, **_hook1; \
\
for( _elt = list; _elt; _elt = _elt->next1 ) \
{ \
_elt->next1 = _elt->next; \
_elt->next = NULL; \
} \
do \
{ \
_hook1 = &( list ); \
while( ( a = *_hook1 ) != NULL && ( b = a->next1 ) != NULL ) \
{ \
_elt = b->next1; \
_list_merge_cond( listtype, a, b, cond, *_hook1 ); \
_hook1 = &( ( *_hook1 )->next1 ); \
*_hook1 = _elt; \
} \
} \
while( _hook1 != &(list) ); \
while( _hook1 != &( list ) ); \
MACRO_END
/* merge two sorted lists. Store result at &result */
#define _list_merge_cond( listtype, a, b, cond, result ) \
MACRO_BEGIN \
listtype * *_hook; \
_hook = &(result); \
while( 1 ) { \
if( a==NULL ) { \
*_hook = b; \
break; \
} \
else if( b==NULL ) { \
*_hook = a; \
break; \
} \
else if( cond ) { \
*_hook = a; \
_hook = &(a->next); \
a = a->next; \
} \
else { \
*_hook = b; \
_hook = &(b->next); \
b = b->next; \
} \
} \
#define _list_merge_cond( listtype, a, b, cond, result ) \
MACRO_BEGIN \
listtype * *_hook; \
_hook = &( result ); \
while( 1 ) \
{ \
if( a == NULL ) \
{ \
*_hook = b; \
break; \
} \
else if( b == NULL ) \
{ \
*_hook = a; \
break; \
} \
else if( cond ) \
{ \
*_hook = a; \
_hook = &( a->next ); \
a = a->next; \
} \
else \
{ \
*_hook = b; \
_hook = &( b->next ); \
b = b->next; \
} \
} \
MACRO_END
/* ---------------------------------------------------------------------- */
/* macros for doubly-linked lists */
#define dlist_append( head, end, elt ) \
MACRO_BEGIN \
#define dlist_append( head, end, elt ) \
MACRO_BEGIN \
elt->prev = end; \
elt->next = NULL; \
if( end ) { \
end->next = elt; \
} \
else { \
head = elt; \
} \
if( end ) \
{ \
end->next = elt; \
} \
else \
{ \
head = elt; \
} \
end = elt; \
MACRO_END
/* let elt be each element of the list, unlinked. At the end, set list=NULL. */
#define dlist_forall_unlink( elt, head, end ) \
for( elt = head; \
elt ? (head = elt->next, elt->next = NULL, elt->prev = NULL), 1 : (end = NULL, 0); \
#define dlist_forall_unlink( elt, head, end ) \
for( elt = head; \
elt ? ( head = elt->next, elt->next = NULL, elt->prev = NULL ), 1 : ( end = NULL, 0 ); \
elt = head )
/* unlink the first element of the list */
#define dlist_unlink_first( head, end, elt ) \
MACRO_BEGIN \
elt = head; \
if( head ) { \
#define dlist_unlink_first( head, end, elt ) \
MACRO_BEGIN \
elt = head; \
if( head ) \
{ \
head = head->next; \
if( head ) { \
head->prev = NULL; \
} \
else { \
end = NULL; \
} \
if( head ) \
{ \
head->prev = NULL; \
} \
else \
{ \
end = NULL; \
} \
elt->prev = NULL; \
elt->next = NULL; \
} \
} \
MACRO_END
#endif /* _PS_LISTS_H */

4
potrace/platform.h
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2001-2015 Peter Selinger.
/* Copyright (C) 2001-2017 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. */
@ -8,7 +8,7 @@
#define PLATFORM_H
#ifdef HAVE_CONFIG_H
#include "config.h"
#include <config.h>
#endif
/* in Windows, set all file i/o to binary */

2
potrace/potrace_version.h
View File

@ -1 +1 @@
#define POTRACELIB_VERSION "potracelib 1.13"
#define POTRACELIB_VERSION "potracelib 1.15"

14
potrace/potracelib.cpp
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2001-2015 Peter Selinger.
/* Copyright (C) 2001-2017 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. */
@ -9,12 +9,11 @@
#include <stdlib.h>
#include <string.h>
#include "potracelib.h"
#include "curve.h"
#include "decompose.h"
#include "trace.h"
#include "potracelib.h"
#include "progress.h"
#include <potrace_version.h>
#include "trace.h"
/* default parameters */
static const potrace_param_t param_default =
@ -38,14 +37,14 @@ potrace_param_t* potrace_param_default( void )
{
potrace_param_t* p;
p = (potrace_param_t*) malloc( sizeof(potrace_param_t) );
p = (potrace_param_t*) malloc( sizeof( potrace_param_t ) );
if( !p )
{
return NULL;
}
memcpy( p, &param_default, sizeof(potrace_param_t) );
memcpy( p, &param_default, sizeof( potrace_param_t ) );
return p;
}
@ -73,7 +72,7 @@ potrace_state_t* potrace_trace( const potrace_param_t* param, const potrace_bitm
prog.d_prev = param->progress.min;
/* allocate state object */
st = (potrace_state_t*) malloc( sizeof(potrace_state_t) );
st = (potrace_state_t*) malloc( sizeof( potrace_state_t ) );
if( !st )
{
@ -128,6 +127,7 @@ void potrace_param_free( potrace_param_t* p )
}
#include "potrace_version.h"
const char* potrace_version( void )
{
return POTRACELIB_VERSION;

17
potrace/potracelib.h
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2001-2015 Peter Selinger.
/* Copyright (C) 2001-2017 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. */
@ -27,7 +27,7 @@ extern "C" {
/* structure to hold progress bar callback data */
struct potrace_progress_s
{
void (* callback)( double progress, void* privdata ); /* callback fn */
void ( * callback )( double progress, void* privdata ); /* callback fn */
void* data; /* callback function's private data */
double min, max; /* desired range of progress, e.g. 0.0 to 1.0 */
double epsilon; /* granularity: can skip smaller increments */
@ -58,9 +58,9 @@ typedef unsigned long potrace_word;
* bit of scanline(n)[0]. */
struct potrace_bitmap_s
{
int w, h; /* width and height, in pixels */
int dy; /* words per scanline (not bytes) */
potrace_word* map; /* raw data, dy*h words */
int w, h; /* width and height, in pixels */
int dy; /* words per scanline (not bytes) */
potrace_word* map; /* raw data, dy*h words */
};
typedef struct potrace_bitmap_s potrace_bitmap_t;
@ -128,9 +128,8 @@ potrace_param_t* potrace_param_default( void );
/* free parameter set */
void potrace_param_free( potrace_param_t* p );
/* trace a bitmap*/
potrace_state_t* potrace_trace( const potrace_param_t* param,
const potrace_bitmap_t* bm );
/* trace a bitmap */
potrace_state_t* potrace_trace( const potrace_param_t* param, const potrace_bitmap_t* bm );
/* free a Potrace state */
void potrace_state_free( potrace_state_t* st );
@ -139,7 +138,7 @@ void potrace_state_free( potrace_state_t* st );
* of potracelib */
const char* potrace_version( void );
#ifdef __cplusplus
#ifdef __cplusplus
} /* end of extern "C" */
#endif

22
potrace/progress.h
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2001-2015 Peter Selinger.
/* Copyright (C) 2001-2017 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. */
@ -14,12 +14,12 @@
/* structure to hold progress bar callback data */
struct progress_s
{
void (* callback)( double progress, void* privdata ); /* callback fn */
void ( * callback )( double progress, void* privdata ); /* callback fn */
void* data; /* callback function's private data */
double min, max; /* desired range of progress, e.g. 0.0 to 1.0 */
double epsilon; /* granularity: can skip smaller increments */
double b; /* upper limit of subrange in superrange units */
double d_prev; /* previous value of d */
double min, max; /* desired range of progress, e.g. 0.0 to 1.0 */
double epsilon; /* granularity: can skip smaller increments */
double b; /* upper limit of subrange in superrange units */
double d_prev; /* previous value of d */
};
typedef struct progress_s progress_t;
@ -32,11 +32,11 @@ static inline void progress_update( double d, progress_t* prog )
if( prog != NULL && prog->callback != NULL )
{
d_scaled = prog->min * (1 - d) + prog->max * d;
d_scaled = prog->min * ( 1 - d ) + prog->max * d;
if( d == 1.0 || d_scaled >= prog->d_prev + prog->epsilon )
{
prog->callback( prog->min * (1 - d) + prog->max * d, prog->data );
prog->callback( prog->min * ( 1 - d ) + prog->max * d, prog->data );
prog->d_prev = d_scaled;
}
}
@ -59,8 +59,8 @@ static inline void progress_subrange_start( double a,
return;
}
min = prog->min * (1 - a) + prog->max * a;
max = prog->min * (1 - b) + prog->max * b;
min = prog->min * ( 1 - a ) + prog->max * a;
max = prog->min * ( 1 - b ) + prog->max * b;
if( max - min < prog->epsilon )
{
@ -71,7 +71,7 @@ static inline void progress_subrange_start( double a,
sub->callback = prog->callback;
sub->data = prog->data;
sub->epsilon = prog->epsilon;
sub->epsilon = prog->epsilon;
sub->min = min;
sub->max = max;
sub->d_prev = prog->d_prev;

71
potrace/render.cpp
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2001-2015 Peter Selinger.
/* Copyright (C) 2001-2017 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. */
@ -6,14 +6,14 @@
#include <config.h>
#endif
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include "render.h"
#include "greymap.h"
#include "auxiliary.h"
#include "greymap.h"
#include "render.h"
/* ---------------------------------------------------------------------- */
/* routines for anti-aliased rendering of curves */
@ -50,16 +50,16 @@ render_t* render_new( greymap_t* gm )
{
render_t* rm;
rm = (render_t*) malloc( sizeof(render_t) );
rm = (render_t*) malloc( sizeof( render_t ) );
if( !rm )
{
return NULL;
}
memset( rm, 0, sizeof(render_t) );
memset( rm, 0, sizeof( render_t ) );
rm->gm = gm;
rm->incrow_buf = (int*) calloc( gm->h, sizeof(int) );
rm->incrow_buf = (int*) calloc( gm->h, sizeof( int ) );
if( !rm->incrow_buf )
{
@ -67,7 +67,6 @@ render_t* render_new( greymap_t* gm )
return NULL;
}
memset( rm->incrow_buf, 0, gm->h * sizeof(int) );
return rm;
}
@ -89,7 +88,7 @@ void render_close( render_t* rm )
render_lineto( rm, rm->x0, rm->y0 );
}
GM_INC( rm->gm, rm->x0i, rm->y0i, (rm->a0 + rm->a1) * 255 );
GM_INC( rm->gm, rm->x0i, rm->y0i, ( rm->a0 + rm->a1 ) * 255 );
/* assert (rm->x0i != rm->x1i || rm->y0i != rm->y1i); */
@ -144,14 +143,14 @@ static void incrow( render_t* rm, int x, int y, int b )
if( x0 < x )
{
for( i = x0; i<x; i++ )
for( i = x0; i < x; i++ )
{
GM_INC( rm->gm, i, y, -b );
}
}
else
{
for( i = x; i<x0; i++ )
for( i = x; i < x0; i++ )
{
GM_INC( rm->gm, i, y, b );
}
@ -165,8 +164,8 @@ 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;
double ss = 2, ts = 2;
double r0, r1;
int i, j;
int rxi, ryi;
int s;
@ -179,27 +178,27 @@ void render_lineto( render_t* rm, double x2, double y2 )
if( sn )
{
s0 = ( (x2>rm->x1 ? rm->x1i + 1 : rm->x1i) - rm->x1 ) / (x2 - rm->x1);
ss = fabs( 1.0 / (x2 - rm->x1) );
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) );
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;
i = 0;
j = 0;
rxi = rm->x1i;
ryi = rm->y1i;
while( i<sn || j<tn )
while( i < sn || j < tn )
{
if( j>=tn || (i<sn && s0 + i * ss < t0 + j * ts) )
if( j >= tn || ( i < sn && s0 + i * ss < t0 + j * ts ) )
{
r1 = s0 + i * ss;
i++;
@ -215,32 +214,32 @@ void render_lineto( render_t* rm, double x2, double y2 )
/* 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 ) );
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 )
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;
rm->a1 += rm->y1 + r1 * ( y2 - rm->y1 ) - ryi;
}
else if( !s && y2>rm->y1 )
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 )
else if( s && x2 <= rm->x1 )
{
rm->a1 -= rm->y1 + r1 * (y2 - rm->y1) - ryi;
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 )
else if( !s && y2 <= rm->y1 )
{
GM_INC( rm->gm, rxi, ryi, rm->a1 * 255 );
rm->a1 = 0;
@ -254,8 +253,8 @@ void render_lineto( render_t* rm, double x2, double y2 )
/* 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->a1 += ( r1 - r0 ) * ( y2 - rm->y1 )
* ( rxi + 1 - ( ( r0 + r1 ) / 2.0 * ( x2 - rm->x1 ) + rm->x1 ) );
rm->x1i = x2i;
rm->y1i = y2i;
@ -290,12 +289,12 @@ void render_curveto( render_t* rm, double x2, double y2, double x3, double y3, d
e2 = 8 * delta <= dd ? 8 * delta / dd : 1;
epsilon = sqrt( e2 ); /* necessary interval size */
for( t = epsilon; t<1; t += epsilon )
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, 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 );

7
potrace/render.h
View File

@ -1,8 +1,7 @@
/* Copyright (C) 2001-2015 Peter Selinger.
/* Copyright (C) 2001-2017 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 RENDER_H
#define RENDER_H
@ -13,8 +12,8 @@ struct render_s
greymap_t* gm;
double x0, y0, x1, y1;
int x0i, y0i, x1i, y1i;
double a0, a1;
int* incrow_buf;
double a0, a1;
int* incrow_buf;
};
typedef struct render_s render_t;

561
potrace/trace.cpp
File diff suppressed because it is too large
View File

5
potrace/trace.h
View File

@ -1,14 +1,13 @@
/* Copyright (C) 2001-2015 Peter Selinger.
/* Copyright (C) 2001-2017 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 TRACE_H
#define TRACE_H
#include "curve.h"
#include "potracelib.h"
#include "progress.h"
#include "curve.h"
int process_path( path_t* plist, const potrace_param_t* param, progress_t* progress );

Write Preview
Loading…
Cancel
Save