mirrors
/
freetype
mirror of https://github.com/freetype/freetype
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

* src/pshinter/pshalgo1.[ch], src/pshinter/pshalgo2.[ch]: Removed. 

* src/pshinter/pshalgo.h: Removed.

* src/pshinter/pshalgo3.[ch]: Renamed to...
* src/pshinter/pshalgo.[ch]: New files.
s/PSH3/PSH/.
s/psh3/psh/.
s/ps3/ps/.

* src/pshinter/pshrec.c, src/pshinter/pshinter.c: Updated.
* src/pshinter/rules.mk, src/pshinter/Jamfile: Updated

* src/pshinter/pshglob.[ch] (psh_dimension_snap_width): Commented
out.

* tests/gview.c: Remove code for pshalgo1 and pshalgo2.
Updated.
This commit is contained in:
Werner Lemberg 2003-05-28 22:42:41 +00:00
parent 26fb1bcd05
commit 0bdf608f3d
17 changed files with 570 additions and 3511 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
ChangeLog
View File

@ -1,3 +1,23 @@
2003-05-29 Werner Lemberg <wl@gnu.org>
* src/pshinter/pshalgo1.[ch], src/pshinter/pshalgo2.[ch]: Removed.
* src/pshinter/pshalgo.h: Removed.
* src/pshinter/pshalgo3.[ch]: Renamed to...
* src/pshinter/pshalgo.[ch]: New files.
s/PSH3/PSH/.
s/psh3/psh/.
s/ps3/ps/.
* src/pshinter/pshrec.c, src/pshinter/pshinter.c: Updated.
* src/pshinter/rules.mk, src/pshinter/Jamfile: Updated
* src/pshinter/pshglob.[ch] (psh_dimension_snap_width): Commented
out.
* tests/gview.c: Remove code for pshalgo1 and pshalgo2.
Updated.
2003-05-28 Martin Zinser <zinser@decus.de>
* vms_make.com: Reworked support for shareable images on VMS. The

6
src/base/ftglyph.c
View File

@ -254,13 +254,13 @@
/* copy it */
FT_MEM_COPY( target->points, source->points,
source->n_points * sizeof ( FT_Vector ) );
source->n_points * sizeof ( FT_Vector ) );
FT_MEM_COPY( target->tags, source->tags,
source->n_points * sizeof ( FT_Byte ) );
source->n_points * sizeof ( FT_Byte ) );
FT_MEM_COPY( target->contours, source->contours,
source->n_contours * sizeof ( FT_Short ) );
source->n_contours * sizeof ( FT_Short ) );
/* copy all flags, except the `FT_OUTLINE_OWNER' one */
target->flags = source->flags | FT_OUTLINE_OWNER;

8
src/base/ftsynth.c
View File

@ -82,14 +82,14 @@
/* we need to compute the `previous' and `next' point */
/* for these extrema. */
cur = outline->points + n;
prev = cur - 1;
next = cur + 1;
cur = outline->points + n;
prev = cur - 1;
next = cur + 1;
first = 0;
for ( c = 0; c < outline->n_contours; c++ )
{
last = outline->contours[c];
last = outline->contours[c];
if ( n == first )
prev = outline->points + last;

2
src/pshinter/Jamfile
View File

@ -8,7 +8,7 @@ SubDir FT2_TOP $(FT2_SRC_DIR) pshinter ;
if $(FT2_MULTI)
{
_sources = pshrec pshglob pshalgo1 pshalgo2 pshalgo3 pshmod ;
_sources = pshrec pshglob pshalgo pshmod ;
}
else
{

572
src/pshinter/pshalgo3.c → src/pshinter/pshalgo.c
View File

File diff suppressed because it is too large Load Diff

236
src/pshinter/pshalgo.h
View File

@ -2,13 +2,13 @@
/* */
/* pshalgo.h */
/* */
/* This header file defines the used hinting algorithm. */
/* PostScript hinting algorithm (specification). */
/* */
/* Copyright 2001 by */
/* Copyright 2001, 2002, 2003 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used */
/* modified and distributed under the terms of the FreeType project */
/* This file is part of the FreeType project, and may only be used, */
/* modified, and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
@ -19,34 +19,236 @@
#ifndef __PSHALGO_H__
#define __PSHALGO_H__
#include "pshrec.h"
#include "pshglob.h"
#include FT_TRIGONOMETRY_H
FT_BEGIN_HEADER
/* define to choose hinting algorithm */
#define PSH_ALGORITHM_3
#if defined(PSH_ALGORITHM_1)
/* handle to Hint structure */
typedef struct PSH_HintRec_* PSH_Hint;
# include "pshalgo1.h"
# define PS_HINTS_APPLY_FUNC ps1_hints_apply
/* hint bit-flags */
typedef enum
{
PSH_HINT_GHOST = PS_HINT_FLAG_GHOST,
PSH_HINT_BOTTOM = PS_HINT_FLAG_BOTTOM,
PSH_HINT_ACTIVE = 4,
PSH_HINT_FITTED = 8
#elif defined(PSH_ALGORITHM_2)
} PSH_Hint_Flags;
# include "pshalgo2.h"
# define PS_HINTS_APPLY_FUNC ps2_hints_apply
#elif defined(PSH_ALGORITHM_3)
#define psh_hint_is_active( x ) ( ( (x)->flags & PSH_HINT_ACTIVE ) != 0 )
#define psh_hint_is_ghost( x ) ( ( (x)->flags & PSH_HINT_GHOST ) != 0 )
#define psh_hint_is_fitted( x ) ( ( (x)->flags & PSH_HINT_FITTED ) != 0 )
# include "pshalgo3.h"
# define PS_HINTS_APPLY_FUNC ps3_hints_apply
#define psh_hint_activate( x ) (x)->flags |= PSH_HINT_ACTIVE
#define psh_hint_deactivate( x ) (x)->flags &= ~PSH_HINT_ACTIVE
#define psh_hint_set_fitted( x ) (x)->flags |= PSH_HINT_FITTED
#else
/* hint structure */
typedef struct PSH_HintRec_
{
FT_Int org_pos;
FT_Int org_len;
FT_Pos cur_pos;
FT_Pos cur_len;
FT_UInt flags;
PSH_Hint parent;
FT_Int order;
# error "invalid Postscript Hinter algorithm selection"
} PSH_HintRec;
/* this is an interpolation zone used for strong points; */
/* weak points are interpolated according to their strong */
/* neighbours */
typedef struct PSH_ZoneRec_
{
FT_Fixed scale;
FT_Fixed delta;
FT_Pos min;
FT_Pos max;
} PSH_ZoneRec, *PSH_Zone;
typedef struct PSH_Hint_TableRec_
{
FT_UInt max_hints;
FT_UInt num_hints;
PSH_Hint hints;
PSH_Hint* sort;
PSH_Hint* sort_global;
FT_UInt num_zones;
PSH_ZoneRec* zones;
PSH_Zone zone;
PS_Mask_Table hint_masks;
PS_Mask_Table counter_masks;
} PSH_Hint_TableRec, *PSH_Hint_Table;
typedef struct PSH_PointRec_* PSH_Point;
typedef struct PSH_ContourRec_* PSH_Contour;
enum
{
PSH_DIR_NONE = 4,
PSH_DIR_UP = -1,
PSH_DIR_DOWN = 1,
PSH_DIR_LEFT = -2,
PSH_DIR_RIGHT = 2
};
#define PSH_DIR_HORIZONTAL 2
#define PSH_DIR_VERTICAL 1
#define PSH_DIR_COMPARE( d1, d2 ) ( (d1) == (d2) || (d1) == -(d2) )
#define PSH_DIR_IS_HORIZONTAL( d ) PSH_DIR_COMPARE( d, PSH_DIR_HORIZONTAL )
#define PSH_DIR_IS_VERTICAL( d ) PSH_DIR_COMPARE( d, PSH_DIR_VERTICAL )
/* the following bit-flags are computed once by the glyph */
/* analyzer, for both dimensions */
enum
{
PSH_POINT_OFF = 1, /* point is off the curve */
PSH_POINT_SMOOTH = 2, /* point is smooth */
PSH_POINT_INFLEX = 4 /* point is inflection */
};
#define psh_point_is_smooth( p ) ( (p)->flags & PSH_POINT_SMOOTH )
#define psh_point_is_off( p ) ( (p)->flags & PSH_POINT_OFF )
#define psh_point_is_inflex( p ) ( (p)->flags & PSH_POINT_INFLEX )
#define psh_point_set_smooth( p ) (p)->flags |= PSH_POINT_SMOOTH
#define psh_point_set_off( p ) (p)->flags |= PSH_POINT_OFF
#define psh_point_set_inflex( p ) (p)->flags |= PSH_POINT_INFLEX
/* the following bit-flags are re-computed for each dimension */
enum
{
PSH_POINT_STRONG = 16, /* point is strong */
PSH_POINT_FITTED = 32, /* point is already fitted */
PSH_POINT_EXTREMUM = 64, /* point is local extremum */
PSH_POINT_POSITIVE = 128, /* extremum has positive contour flow */
PSH_POINT_NEGATIVE = 256, /* extremum has negative contour flow */
PSH_POINT_EDGE_MIN = 512, /* point is aligned to left/bottom stem edge */
PSH_POINT_EDGE_MAX = 1024 /* point is aligned to top/right stem edge */
};
#define psh_point_is_strong( p ) ( (p)->flags2 & PSH_POINT_STRONG )
#define psh_point_is_fitted( p ) ( (p)->flags2 & PSH_POINT_FITTED )
#define psh_point_is_extremum( p ) ( (p)->flags2 & PSH_POINT_EXTREMUM )
#define psh_point_is_positive( p ) ( (p)->flags2 & PSH_POINT_POSITIVE )
#define psh_point_is_negative( p ) ( (p)->flags2 & PSH_POINT_NEGATIVE )
#define psh_point_is_edge_min( p ) ( (p)->flags2 & PSH_POINT_EDGE_MIN )
#define psh_point_is_edge_max( p ) ( (p)->flags2 & PSH_POINT_EDGE_MAX )
#define psh_point_set_strong( p ) (p)->flags2 |= PSH_POINT_STRONG
#define psh_point_set_fitted( p ) (p)->flags2 |= PSH_POINT_FITTED
#define psh_point_set_extremum( p ) (p)->flags2 |= PSH_POINT_EXTREMUM
#define psh_point_set_positive( p ) (p)->flags2 |= PSH_POINT_POSITIVE
#define psh_point_set_negative( p ) (p)->flags2 |= PSH_POINT_NEGATIVE
#define psh_point_set_edge_min( p ) (p)->flags2 |= PSH_POINT_EDGE_MIN
#define psh_point_set_edge_max( p ) (p)->flags2 |= PSH_POINT_EDGE_MAX
typedef struct PSH_PointRec_
{
PSH_Point prev;
PSH_Point next;
PSH_Contour contour;
FT_UInt flags;
FT_UInt flags2;
FT_Char dir_in;
FT_Char dir_out;
FT_Angle angle_in;
FT_Angle angle_out;
PSH_Hint hint;
FT_Pos org_u;
FT_Pos org_v;
FT_Pos cur_u;
#ifdef DEBUG_HINTER
FT_Pos org_x;
FT_Pos cur_x;
FT_Pos org_y;
FT_Pos cur_y;
FT_UInt flags_x;
FT_UInt flags_y;
#endif
} PSH_PointRec;
#define PSH_POINT_EQUAL_ORG( a, b ) ( (a)->org_u == (b)->org_u && \
(a)->org_v == (b)->org_v )
#define PSH_POINT_ANGLE( a, b ) FT_Atan2( (b)->org_u - (a)->org_u, \
(b)->org_v - (a)->org_v )
typedef struct PSH_ContourRec_
{
PSH_Point start;
FT_UInt count;
} PSH_ContourRec;
typedef struct PSH_GlyphRec_
{
FT_UInt num_points;
FT_UInt num_contours;
PSH_Point points;
PSH_Contour contours;
FT_Memory memory;
FT_Outline* outline;
PSH_Globals globals;
PSH_Hint_TableRec hint_tables[2];
FT_Bool vertical;
FT_Int major_dir;
FT_Int minor_dir;
FT_Bool do_horz_hints;
FT_Bool do_vert_hints;
FT_Bool do_horz_snapping;
FT_Bool do_vert_snapping;
FT_Bool do_stem_adjust;
} PSH_GlyphRec, *PSH_Glyph;
#ifdef DEBUG_HINTER
extern PSH_Hint_Table ps_debug_hint_table;
typedef void
(*PSH_HintFunc)( PSH_Hint hint,
FT_Bool vertical );
extern PSH_HintFunc ps_debug_hint_func;
extern PSH_Glyph ps_debug_glyph;
#endif
extern FT_Error
ps_hints_apply( PS_Hints ps_hints,
FT_Outline* outline,
PSH_Globals globals,
FT_Render_Mode hint_mode );
FT_END_HEADER
#endif /* __PSHALGO_H__ */

785
src/pshinter/pshalgo1.c
View File

@ -1,785 +0,0 @@
/***************************************************************************/
/* */
/* pshalgo1.c */
/* */
/* PostScript hinting algorithm 1 (body). */
/* */
/* Copyright 2001, 2002 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used */
/* modified and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/
#include <ft2build.h>
#include FT_INTERNAL_OBJECTS_H
#include FT_INTERNAL_DEBUG_H
#include "pshalgo1.h"
#undef FT_COMPONENT
#define FT_COMPONENT trace_pshalgo1
#ifdef DEBUG_HINTER
PSH1_Hint_Table ps1_debug_hint_table = 0;
PSH1_HintFunc ps1_debug_hint_func = 0;
#endif
/************************************************************************/
/************************************************************************/
/***** *****/
/***** BASIC HINTS RECORDINGS *****/
/***** *****/
/************************************************************************/
/************************************************************************/
/* return true iff two stem hints overlap */
static FT_Int
psh1_hint_overlap( PSH1_Hint hint1,
PSH1_Hint hint2 )
{
return ( hint1->org_pos + hint1->org_len >= hint2->org_pos &&
hint2->org_pos + hint2->org_len >= hint1->org_pos );
}
/* destroy hints table */
static void
psh1_hint_table_done( PSH1_Hint_Table table,
FT_Memory memory )
{
FT_FREE( table->zones );
table->num_zones = 0;
table->zone = 0;
FT_FREE( table->sort );
FT_FREE( table->hints );
table->num_hints = 0;
table->max_hints = 0;
table->sort_global = 0;
}
/* deactivate all hints in a table */
static void
psh1_hint_table_deactivate( PSH1_Hint_Table table )
{
FT_UInt count = table->max_hints;
PSH1_Hint hint = table->hints;
for ( ; count > 0; count--, hint++ )
{
psh1_hint_deactivate( hint );
hint->order = -1;
}
}
/* internal function used to record a new hint */
static void
psh1_hint_table_record( PSH1_Hint_Table table,
FT_UInt idx )
{
PSH1_Hint hint = table->hints + idx;
if ( idx >= table->max_hints )
{
FT_ERROR(( "%s.activate: invalid hint index %d\n", idx ));
return;
}
/* ignore active hints */
if ( psh1_hint_is_active( hint ) )
return;
psh1_hint_activate( hint );
/* now scan the current active hint set in order to determine */
/* if we are overlapping with another segment */
{
PSH1_Hint* sorted = table->sort_global;
FT_UInt count = table->num_hints;
PSH1_Hint hint2;
hint->parent = 0;
for ( ; count > 0; count--, sorted++ )
{
hint2 = sorted[0];
if ( psh1_hint_overlap( hint, hint2 ) )
{
hint->parent = hint2;
break;
}
}
}
if ( table->num_hints < table->max_hints )
table->sort_global[table->num_hints++] = hint;
else
FT_ERROR(( "%s.activate: too many sorted hints! BUG!\n",
"ps.fitter" ));
}
static void
psh1_hint_table_record_mask( PSH1_Hint_Table table,
PS_Mask hint_mask )
{
FT_Int mask = 0, val = 0;
FT_Byte* cursor = hint_mask->bytes;
FT_UInt idx, limit;
limit = hint_mask->num_bits;
if ( limit != table->max_hints )
FT_ERROR(( "%s.activate_mask: invalid bit count (%d instead of %d)\n",
"ps.fitter", hint_mask->num_bits, table->max_hints ));
for ( idx = 0; idx < limit; idx++ )
{
if ( mask == 0 )
{
val = *cursor++;
mask = 0x80;
}
if ( val & mask )
psh1_hint_table_record( table, idx );
mask >>= 1;
}
}
/* create hints table */
static FT_Error
psh1_hint_table_init( PSH1_Hint_Table table,
PS_Hint_Table hints,
PS_Mask_Table hint_masks,
PS_Mask_Table counter_masks,
FT_Memory memory )
{
FT_UInt count = hints->num_hints;
FT_Error error;
FT_UNUSED( counter_masks );
/* allocate our tables */
if ( FT_NEW_ARRAY( table->sort, 2 * count ) ||
FT_NEW_ARRAY( table->hints, count ) ||
FT_NEW_ARRAY( table->zones, 2 * count + 1 ) )
goto Exit;
table->max_hints = count;
table->sort_global = table->sort + count;
table->num_hints = 0;
table->num_zones = 0;
table->zone = 0;
/* now, initialize the "hints" array */
{
PSH1_Hint write = table->hints;
PS_Hint read = hints->hints;
for ( ; count > 0; count--, write++, read++ )
{
write->org_pos = read->pos;
write->org_len = read->len;
write->flags = read->flags;
}
}
/* we now need to determine the initial "parent" stems; first */
/* activate the hints that are given by the initial hint masks */
if ( hint_masks )
{
FT_UInt Count = hint_masks->num_masks;
PS_Mask Mask = hint_masks->masks;
table->hint_masks = hint_masks;
for ( ; Count > 0; Count--, Mask++ )
psh1_hint_table_record_mask( table, Mask );
}
/* now, do a linear parse in case some hints were left alone */
if ( table->num_hints != table->max_hints )
{
FT_UInt Index, Count;
FT_ERROR(( "%s.init: missing/incorrect hint masks!\n" ));
Count = table->max_hints;
for ( Index = 0; Index < Count; Index++ )
psh1_hint_table_record( table, Index );
}
Exit:
return error;
}
static void
psh1_hint_table_activate_mask( PSH1_Hint_Table table,
PS_Mask hint_mask )
{
FT_Int mask = 0, val = 0;
FT_Byte* cursor = hint_mask->bytes;
FT_UInt idx, limit, count;
limit = hint_mask->num_bits;
count = 0;
psh1_hint_table_deactivate( table );
for ( idx = 0; idx < limit; idx++ )
{
if ( mask == 0 )
{
val = *cursor++;
mask = 0x80;
}
if ( val & mask )
{
PSH1_Hint hint = &table->hints[idx];
if ( !psh1_hint_is_active( hint ) )
{
PSH1_Hint* sort = table->sort;
FT_UInt count2;
PSH1_Hint hint2;
for ( count2 = count; count2 > 0; count2--, sort++ )
{
hint2 = sort[0];
if ( psh1_hint_overlap( hint, hint2 ) )
{
FT_ERROR(( "%s.activate_mask: found overlapping hints\n",
"psf.hint" ));
break;
}
}
if ( count2 == 0 )
{
psh1_hint_activate( hint );
if ( count < table->max_hints )
table->sort[count++] = hint;
else
FT_ERROR(( "%s.activate_mask: too many active hints\n",
"psf.hint" ));
}
}
}
mask >>= 1;
}
table->num_hints = count;
/* now, sort the hints; they are guaranteed to not overlap */
/* so we can compare their "org_pos" field directly */
{
FT_Int i1, i2;
PSH1_Hint hint1, hint2;
PSH1_Hint* sort = table->sort;
/* a simple bubble sort will do, since in 99% of cases, the hints */
/* will be already sorted; and the sort will be linear */
for ( i1 = 1; i1 < (FT_Int)count; i1++ )
{
hint1 = sort[i1];
for ( i2 = i1 - 1; i2 >= 0; i2-- )
{
hint2 = sort[i2];
if ( hint2->org_pos < hint1->org_pos )
break;
sort[i2 + 1] = hint2;
sort[i2] = hint1;
}
}
}
}
/*************************************************************************/
/*************************************************************************/
/***** *****/
/***** HINTS GRID-FITTING AND OPTIMIZATION *****/
/***** *****/
/*************************************************************************/
/*************************************************************************/
#ifdef DEBUG_HINTER
void
ps_simple_scale( PSH1_Hint_Table table,
FT_Fixed scale,
FT_Fixed delta,
FT_Int vertical )
{
PSH1_Hint hint;
FT_UInt count;
for ( count = 0; count < table->num_hints; count++ )
{
hint = table->sort[count];
if ( psh1_hint_is_active( hint ) )
{
hint->cur_pos = FT_MulFix( hint->org_pos, scale ) + delta;
hint->cur_len = FT_MulFix( hint->org_len, scale );
if ( ps1_debug_hint_func )
ps1_debug_hint_func( hint, vertical );
}
}
}
#endif
FT_LOCAL_DEF( FT_Error )
psh1_hint_table_optimize( PSH1_Hint_Table table,
PSH_Globals globals,
FT_Outline* outline,
FT_Int vertical )
{
PSH_Dimension dim = &globals->dimension[vertical];
FT_Fixed scale = dim->scale_mult;
FT_Fixed delta = dim->scale_delta;
FT_UNUSED( outline );
#ifdef DEBUG_HINTER
if ( ps_debug_no_vert_hints && vertical )
{
ps_simple_scale( table, scale, delta, vertical );
return 0;
}
if ( ps_debug_no_horz_hints && !vertical )
{
ps_simple_scale( table, scale, delta, vertical );
return 0;
}
#endif
/* XXXX: for now, we only scale the hints to test all other aspects */
/* of the PostScript hinter */
{
PSH1_Hint hint;
FT_UInt count;
for ( count = 0; count < table->num_hints; count++ )
{
hint = table->sort[count];
if ( psh1_hint_is_active( hint ) )
{
#if 1
FT_Pos pos = FT_MulFix( hint->org_pos, scale ) + delta;
FT_Pos len = FT_MulFix( hint->org_len, scale );
FT_Pos fit_center;
FT_Pos fit_len;
PSH_AlignmentRec align;
/* compute fitted width/height */
fit_len = psh_dimension_snap_width( dim, hint->org_len );
if ( fit_len < 64 )
fit_len = 64;
else
fit_len = ( fit_len + 32 ) & -64;
hint->cur_len = fit_len;
/* check blue zones for horizontal stems */
align.align = PSH_BLUE_ALIGN_NONE;
align.align_bot = align.align_top = 0;
if ( !vertical )
{
psh_blues_snap_stem( &globals->blues,
hint->org_pos + hint->org_len,
hint->org_pos,
&align );
}
switch ( align.align )
{
case PSH_BLUE_ALIGN_TOP:
/* the top of the stem is aligned against a blue zone */
hint->cur_pos = align.align_top - fit_len;
break;
case PSH_BLUE_ALIGN_BOT:
/* the bottom of the stem is aligned against a blue zone */
hint->cur_pos = align.align_bot;
break;
case PSH_BLUE_ALIGN_TOP | PSH_BLUE_ALIGN_BOT:
/* both edges of the stem are aligned against blue zones */
hint->cur_pos = align.align_bot;
hint->cur_len = align.align_top - align.align_bot;
break;
default:
/* normal processing */
if ( ( fit_len / 64 ) & 1 )
{
/* odd number of pixels */
fit_center = ( ( pos + ( len >> 1 ) ) & -64 ) + 32;
}
else
{
/* even number of pixels */
fit_center = ( pos + ( len >> 1 ) + 32 ) & -64;
}
hint->cur_pos = fit_center - ( fit_len >> 1 );
}
# else
hint->cur_pos = ( FT_MulFix( hint->org_pos, scale ) + delta + 32 )
& -64;
hint->cur_len = FT_MulFix( hint->org_len, scale );
# endif
#ifdef DEBUG_HINTER
if ( ps1_debug_hint_func )
ps1_debug_hint_func( hint, vertical );
#endif
}
}
}
return 0;
}
/*************************************************************************/
/*************************************************************************/
/***** *****/
/***** POINTS INTERPOLATION ROUTINES *****/
/***** *****/
/*************************************************************************/
/*************************************************************************/
#define PSH1_ZONE_MIN -3200000
#define PSH1_ZONE_MAX +3200000
#define xxDEBUG_ZONES
#ifdef DEBUG_ZONES
#include <stdio.h>
static void
psh1_print_zone( PSH1_Zone zone )
{
printf( "zone [scale,delta,min,max] = [%.3f,%.3f,%d,%d]\n",
zone->scale / 65536.0,
zone->delta / 64.0,
zone->min,
zone->max );
}
#else
#define psh1_print_zone( x ) do { } while ( 0 )
#endif
/* setup interpolation zones once the hints have been grid-fitted */
/* by the optimizer */
static void
psh1_hint_table_setup_zones( PSH1_Hint_Table table,
FT_Fixed scale,
FT_Fixed delta )
{
FT_UInt count;
PSH1_Zone zone;
PSH1_Hint *sort, hint, hint2;
zone = table->zones;
/* special case, no hints defined */
if ( table->num_hints == 0 )
{
zone->scale = scale;
zone->delta = delta;
zone->min = PSH1_ZONE_MIN;
zone->max = PSH1_ZONE_MAX;
table->num_zones = 1;
table->zone = zone;
return;
}
/* the first zone is before the first hint */
/* x' = (x-x0)*s + x0' = x*s + ( x0' - x0*s ) */
sort = table->sort;
hint = sort[0];
zone->scale = scale;
zone->delta = hint->cur_pos - FT_MulFix( hint->org_pos, scale );
zone->min = PSH1_ZONE_MIN;
zone->max = hint->org_pos;
psh1_print_zone( zone );
zone++;
for ( count = table->num_hints; count > 0; count-- )
{
FT_Fixed scale2;
if ( hint->org_len > 0 )
{
/* setup a zone for inner-stem interpolation */
/* (x' - x0') = (x - x0)*(x1'-x0')/(x1-x0) */
/* x' = x*s2 + x0' - x0*s2 */
scale2 = FT_DivFix( hint->cur_len, hint->org_len );
zone->scale = scale2;
zone->min = hint->org_pos;
zone->max = hint->org_pos + hint->org_len;
zone->delta = hint->cur_pos - FT_MulFix( zone->min, scale2 );
psh1_print_zone( zone );
zone++;
}
if ( count == 1 )
break;
sort++;
hint2 = sort[0];
/* setup zone for inter-stem interpolation */
/* (x'-x1') = (x-x1)*(x2'-x1')/(x2-x1) */
/* x' = x*s3 + x1' - x1*s3 */
scale2 = FT_DivFix( hint2->cur_pos - (hint->cur_pos + hint->cur_len),
hint2->org_pos - (hint->org_pos + hint->org_len) );
zone->scale = scale2;
zone->min = hint->org_pos + hint->org_len;
zone->max = hint2->org_pos;
zone->delta = hint->cur_pos + hint->cur_len -
FT_MulFix( zone->min, scale2 );
psh1_print_zone( zone );
zone++;
hint = hint2;
}
/* the last zone */
zone->scale = scale;
zone->min = hint->org_pos + hint->org_len;
zone->max = PSH1_ZONE_MAX;
zone->delta = hint->cur_pos + hint->cur_len -
FT_MulFix( zone->min, scale );
psh1_print_zone( zone );
zone++;
table->num_zones = zone - table->zones;
table->zone = table->zones;
}
/* tune a single coordinate with the current interpolation zones */
static FT_Pos
psh1_hint_table_tune_coord( PSH1_Hint_Table table,
FT_Int coord )
{
PSH1_Zone zone;
zone = table->zone;
if ( coord < zone->min )
{
do
{
if ( zone == table->zones )
break;
zone--;
} while ( coord < zone->min );
table->zone = zone;
}
else if ( coord > zone->max )
{
do
{
if ( zone == table->zones + table->num_zones - 1 )
break;
zone++;
} while ( coord > zone->max );
table->zone = zone;
}
return FT_MulFix( coord, zone->scale ) + zone->delta;
}
/* tune a given outline with current interpolation zones. */
/* The function only works in a single dimension. */
static void
psh1_hint_table_tune_outline( PSH1_Hint_Table table,
FT_Outline* outline,
PSH_Globals globals,
FT_Int vertical )
{
FT_UInt count, first, last;
PS_Mask_Table hint_masks = table->hint_masks;
PS_Mask mask;
PSH_Dimension dim = &globals->dimension[vertical];
FT_Fixed scale = dim->scale_mult;
FT_Fixed delta = dim->scale_delta;
if ( hint_masks && hint_masks->num_masks > 0 )
{
first = 0;
mask = hint_masks->masks;
count = hint_masks->num_masks;
for ( ; count > 0; count--, mask++ )
{
last = mask->end_point;
if ( last > first )
{
FT_Vector* vec;
FT_Int count2;
psh1_hint_table_activate_mask( table, mask );
psh1_hint_table_optimize( table, globals, outline, vertical );
psh1_hint_table_setup_zones( table, scale, delta );
last = mask->end_point;
vec = outline->points + first;
count2 = last - first;
for ( ; count2 > 0; count2--, vec++ )
{
FT_Pos x, *px;
px = vertical ? &vec->x : &vec->y;
x = *px;
*px = psh1_hint_table_tune_coord( table, (FT_Int)x );
}
}
first = last;
}
}
else /* no hints in this glyph, simply scale the outline */
{
FT_Vector* vec;
vec = outline->points;
count = outline->n_points;
if ( vertical )
{
for ( ; count > 0; count--, vec++ )
vec->x = FT_MulFix( vec->x, scale ) + delta;
}
else
{
for ( ; count > 0; count--, vec++ )
vec->y = FT_MulFix( vec->y, scale ) + delta;
}
}
}
/*************************************************************************/
/*************************************************************************/
/***** *****/
/***** HIGH-LEVEL INTERFACE *****/
/***** *****/
/*************************************************************************/
/*************************************************************************/
FT_Error
ps1_hints_apply( PS_Hints ps_hints,
FT_Outline* outline,
PSH_Globals globals,
FT_Render_Mode hint_mode )
{
PSH1_Hint_TableRec hints;
FT_Error error = 0;
FT_Int dimension;
FT_UNUSED( hint_mode );
for ( dimension = 1; dimension >= 0; dimension-- )
{
PS_Dimension dim = &ps_hints->dimension[dimension];
/* initialize hints table */
FT_MEM_ZERO( &hints, sizeof ( hints ) );
error = psh1_hint_table_init( &hints,
&dim->hints,
&dim->masks,
&dim->counters,
ps_hints->memory );
if ( error )
goto Exit;
psh1_hint_table_tune_outline( &hints,
outline,
globals,
dimension );
psh1_hint_table_done( &hints, ps_hints->memory );
}
Exit:
return error;
}
/* END */

110
src/pshinter/pshalgo1.h
View File

@ -1,110 +0,0 @@
/***************************************************************************/
/* */
/* pshalgo1.h */
/* */
/* PostScript hinting algorithm 1 (specification). */
/* */
/* Copyright 2001 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
/* modified, and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/
#ifndef __PSHALGO1_H__
#define __PSHALGO1_H__
#include "pshrec.h"
FT_BEGIN_HEADER
typedef struct PSH1_HintRec_* PSH1_Hint;
typedef enum
{
PSH1_HINT_FLAG_GHOST = PS_HINT_FLAG_GHOST,
PSH1_HINT_FLAG_BOTTOM = PS_HINT_FLAG_BOTTOM,
PSH1_HINT_FLAG_ACTIVE = 4
} PSH1_Hint_Flags;
#define psh1_hint_is_active( x ) \
( ( (x)->flags & PSH1_HINT_FLAG_ACTIVE ) != 0 )
#define psh1_hint_is_ghost( x ) \
( ( (x)->flags & PSH1_HINT_FLAG_GHOST ) != 0 )
#define psh1_hint_activate( x ) (x)->flags |= PSH1_HINT_FLAG_ACTIVE
#define psh1_hint_deactivate( x ) (x)->flags &= ~PSH1_HINT_FLAG_ACTIVE
typedef struct PSH1_HintRec_
{
FT_Int org_pos;
FT_Int org_len;
FT_Pos cur_pos;
FT_Pos cur_len;
FT_UInt flags;
PSH1_Hint parent;
FT_Int order;
} PSH1_HintRec;
/* this is an interpolation zone used for strong points; */
/* weak points are interpolated according to their strong */
/* neighbours */
typedef struct PSH1_ZoneRec_
{
FT_Fixed scale;
FT_Fixed delta;
FT_Pos min;
FT_Pos max;
} PSH1_ZoneRec, *PSH1_Zone;
typedef struct PSH1_Hint_TableRec_
{
FT_UInt max_hints;
FT_UInt num_hints;
PSH1_Hint hints;
PSH1_Hint* sort;
PSH1_Hint* sort_global;
FT_UInt num_zones;
PSH1_Zone zones;
PSH1_Zone zone;
PS_Mask_Table hint_masks;
PS_Mask_Table counter_masks;
} PSH1_Hint_TableRec, *PSH1_Hint_Table;
extern FT_Error
ps1_hints_apply( PS_Hints ps_hints,
FT_Outline* outline,
PSH_Globals globals,
FT_Render_Mode hint_mode );
#ifdef DEBUG_HINTER
extern PSH1_Hint_Table ps1_debug_hint_table;
typedef void
(*PSH1_HintFunc)( PSH1_Hint hint,
FT_Bool vertical );
extern PSH1_HintFunc ps1_debug_hint_func;
#endif
FT_END_HEADER
#endif /* __PSHALGO1_H__ */
/* END */

1557
src/pshinter/pshalgo2.c
View File

File diff suppressed because it is too large Load Diff

203
src/pshinter/pshalgo2.h
View File

@ -1,203 +0,0 @@
/***************************************************************************/
/* */
/* pshalgo2.h */
/* */
/* PostScript hinting algorithm 2 (specification). */
/* */
/* Copyright 2001 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
/* modified, and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/
#ifndef __PSHALGO2_H__
#define __PSHALGO2_H__
#include "pshrec.h"
#include "pshglob.h"
#include FT_TRIGONOMETRY_H
FT_BEGIN_HEADER
typedef struct PSH2_HintRec_* PSH2_Hint;
typedef enum
{
PSH2_HINT_GHOST = PS_HINT_FLAG_GHOST,
PSH2_HINT_BOTTOM = PS_HINT_FLAG_BOTTOM,
PSH2_HINT_ACTIVE = 4,
PSH2_HINT_FITTED = 8
} PSH2_Hint_Flags;
#define psh2_hint_is_active( x ) ( ( (x)->flags & PSH2_HINT_ACTIVE ) != 0 )
#define psh2_hint_is_ghost( x ) ( ( (x)->flags & PSH2_HINT_GHOST ) != 0 )
#define psh2_hint_is_fitted( x ) ( ( (x)->flags & PSH2_HINT_FITTED ) != 0 )
#define psh2_hint_activate( x ) (x)->flags |= PSH2_HINT_ACTIVE
#define psh2_hint_deactivate( x ) (x)->flags &= ~PSH2_HINT_ACTIVE
#define psh2_hint_set_fitted( x ) (x)->flags |= PSH2_HINT_FITTED
typedef struct PSH2_HintRec_
{
FT_Int org_pos;
FT_Int org_len;
FT_Pos cur_pos;
FT_Pos cur_len;
FT_UInt flags;
PSH2_Hint parent;
FT_Int order;
} PSH2_HintRec;
/* this is an interpolation zone used for strong points; */
/* weak points are interpolated according to their strong */
/* neighbours */
typedef struct PSH2_ZoneRec_
{
FT_Fixed scale;
FT_Fixed delta;
FT_Pos min;
FT_Pos max;
} PSH2_ZoneRec, *PSH2_Zone;
typedef struct PSH2_Hint_TableRec_
{
FT_UInt max_hints;
FT_UInt num_hints;
PSH2_Hint hints;
PSH2_Hint* sort;
PSH2_Hint* sort_global;
FT_UInt num_zones;
PSH2_Zone zones;
PSH2_Zone zone;
PS_Mask_Table hint_masks;
PS_Mask_Table counter_masks;
} PSH2_Hint_TableRec, *PSH2_Hint_Table;
typedef struct PSH2_PointRec_* PSH2_Point;
typedef struct PSH2_ContourRec_* PSH2_Contour;
enum
{
PSH2_DIR_NONE = 4,
PSH2_DIR_UP = 1,
PSH2_DIR_DOWN = -1,
PSH2_DIR_LEFT = -2,
PSH2_DIR_RIGHT = 2
};
enum
{
PSH2_POINT_OFF = 1, /* point is off the curve */
PSH2_POINT_STRONG = 2, /* point is strong */
PSH2_POINT_SMOOTH = 4, /* point is smooth */
PSH2_POINT_FITTED = 8 /* point is already fitted */
};
typedef struct PSH2_PointRec_
{
PSH2_Point prev;
PSH2_Point next;
PSH2_Contour contour;
FT_UInt flags;
FT_Char dir_in;
FT_Char dir_out;
FT_Angle angle_in;
FT_Angle angle_out;
PSH2_Hint hint;
FT_Pos org_u;
FT_Pos cur_u;
#ifdef DEBUG_HINTER
FT_Pos org_x;
FT_Pos cur_x;
FT_Pos org_y;
FT_Pos cur_y;
FT_UInt flags_x;
FT_UInt flags_y;
#endif
} PSH2_PointRec;
#define psh2_point_is_strong( p ) ( (p)->flags & PSH2_POINT_STRONG )
#define psh2_point_is_fitted( p ) ( (p)->flags & PSH2_POINT_FITTED )
#define psh2_point_is_smooth( p ) ( (p)->flags & PSH2_POINT_SMOOTH )
#define psh2_point_set_strong( p ) (p)->flags |= PSH2_POINT_STRONG
#define psh2_point_set_fitted( p ) (p)->flags |= PSH2_POINT_FITTED
#define psh2_point_set_smooth( p ) (p)->flags |= PSH2_POINT_SMOOTH
typedef struct PSH2_ContourRec_
{
PSH2_Point start;
FT_UInt count;
} PSH2_ContourRec;
typedef struct PSH2_GlyphRec_
{
FT_UInt num_points;
FT_UInt num_contours;
PSH2_Point points;
PSH2_Contour contours;
FT_Memory memory;
FT_Outline* outline;
PSH_Globals globals;
PSH2_Hint_TableRec hint_tables[2];
FT_Bool vertical;
FT_Int major_dir;
FT_Int minor_dir;
} PSH2_GlyphRec, *PSH2_Glyph;
#ifdef DEBUG_HINTER
extern PSH2_Hint_Table ps2_debug_hint_table;
typedef void
(*PSH2_HintFunc)( PSH2_Hint hint,
FT_Bool vertical );
extern PSH2_HintFunc ps2_debug_hint_func;
extern PSH2_Glyph ps2_debug_glyph;
#endif
extern FT_Error
ps2_hints_apply( PS_Hints ps_hints,
FT_Outline* outline,
PSH_Globals globals,
FT_Render_Mode hint_mode );
FT_END_HEADER
#endif /* __PSHALGO2_H__ */
/* END */

255
src/pshinter/pshalgo3.h
View File

@ -1,255 +0,0 @@
/***************************************************************************/
/* */
/* pshalgo3.h */
/* */
/* PostScript hinting algorithm 3 (specification). */
/* */
/* Copyright 2001, 2002 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
/* modified, and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/
#ifndef __PSHALGO3_H__
#define __PSHALGO3_H__
#include "pshrec.h"
#include "pshglob.h"
#include FT_TRIGONOMETRY_H
FT_BEGIN_HEADER
/* handle to Hint structure */
typedef struct PSH3_HintRec_* PSH3_Hint;
/* hint bit-flags */
typedef enum
{
PSH3_HINT_GHOST = PS_HINT_FLAG_GHOST,
PSH3_HINT_BOTTOM = PS_HINT_FLAG_BOTTOM,
PSH3_HINT_ACTIVE = 4,
PSH3_HINT_FITTED = 8
} PSH3_Hint_Flags;
#define psh3_hint_is_active( x ) ( ( (x)->flags & PSH3_HINT_ACTIVE ) != 0 )
#define psh3_hint_is_ghost( x ) ( ( (x)->flags & PSH3_HINT_GHOST ) != 0 )
#define psh3_hint_is_fitted( x ) ( ( (x)->flags & PSH3_HINT_FITTED ) != 0 )
#define psh3_hint_activate( x ) (x)->flags |= PSH3_HINT_ACTIVE
#define psh3_hint_deactivate( x ) (x)->flags &= ~PSH3_HINT_ACTIVE
#define psh3_hint_set_fitted( x ) (x)->flags |= PSH3_HINT_FITTED
/* hint structure */
typedef struct PSH3_HintRec_
{
FT_Int org_pos;
FT_Int org_len;
FT_Pos cur_pos;
FT_Pos cur_len;
FT_UInt flags;
PSH3_Hint parent;
FT_Int order;
} PSH3_HintRec;
/* this is an interpolation zone used for strong points; */
/* weak points are interpolated according to their strong */
/* neighbours */
typedef struct PSH3_ZoneRec_
{
FT_Fixed scale;
FT_Fixed delta;
FT_Pos min;
FT_Pos max;
} PSH3_ZoneRec, *PSH3_Zone;
typedef struct PSH3_Hint_TableRec_
{
FT_UInt max_hints;
FT_UInt num_hints;
PSH3_Hint hints;
PSH3_Hint* sort;
PSH3_Hint* sort_global;
FT_UInt num_zones;
PSH3_ZoneRec* zones;
PSH3_Zone zone;
PS_Mask_Table hint_masks;
PS_Mask_Table counter_masks;
} PSH3_Hint_TableRec, *PSH3_Hint_Table;
typedef struct PSH3_PointRec_* PSH3_Point;
typedef struct PSH3_ContourRec_* PSH3_Contour;
enum
{
PSH3_DIR_NONE = 4,
PSH3_DIR_UP = -1,
PSH3_DIR_DOWN = 1,
PSH3_DIR_LEFT = -2,
PSH3_DIR_RIGHT = 2
};
#define PSH3_DIR_HORIZONTAL 2
#define PSH3_DIR_VERTICAL 1
#define PSH3_DIR_COMPARE( d1, d2 ) ( (d1) == (d2) || (d1) == -(d2) )
#define PSH3_DIR_IS_HORIZONTAL( d ) PSH3_DIR_COMPARE( d, PSH3_DIR_HORIZONTAL )
#define PSH3_DIR_IS_VERTICAL( d ) PSH3_DIR_COMPARE( d, PSH3_DIR_VERTICAL )
/* the following bit-flags are computed once by the glyph */
/* analyzer, for both dimensions */
enum
{
PSH3_POINT_OFF = 1, /* point is off the curve */
PSH3_POINT_SMOOTH = 2, /* point is smooth */
PSH3_POINT_INFLEX = 4 /* point is inflection */
};
#define psh3_point_is_smooth( p ) ( (p)->flags & PSH3_POINT_SMOOTH )
#define psh3_point_is_off( p ) ( (p)->flags & PSH3_POINT_OFF )
#define psh3_point_is_inflex( p ) ( (p)->flags & PSH3_POINT_INFLEX )
#define psh3_point_set_smooth( p ) (p)->flags |= PSH3_POINT_SMOOTH
#define psh3_point_set_off( p ) (p)->flags |= PSH3_POINT_OFF
#define psh3_point_set_inflex( p ) (p)->flags |= PSH3_POINT_INFLEX
/* the following bit-flags are re-computed for each dimension */
enum
{
PSH3_POINT_STRONG = 16, /* point is strong */
PSH3_POINT_FITTED = 32, /* point is already fitted */
PSH3_POINT_EXTREMUM = 64, /* point is local extremum */
PSH3_POINT_POSITIVE = 128, /* extremum has positive contour flow */
PSH3_POINT_NEGATIVE = 256, /* extremum has negative contour flow */
PSH3_POINT_EDGE_MIN = 512, /* point is aligned to left/bottom stem edge */
PSH3_POINT_EDGE_MAX = 1024 /* point is aligned to top/right stem edge */
};
#define psh3_point_is_strong( p ) ( (p)->flags2 & PSH3_POINT_STRONG )
#define psh3_point_is_fitted( p ) ( (p)->flags2 & PSH3_POINT_FITTED )
#define psh3_point_is_extremum( p ) ( (p)->flags2 & PSH3_POINT_EXTREMUM )
#define psh3_point_is_positive( p ) ( (p)->flags2 & PSH3_POINT_POSITIVE )
#define psh3_point_is_negative( p ) ( (p)->flags2 & PSH3_POINT_NEGATIVE )
#define psh3_point_is_edge_min( p ) ( (p)->flags2 & PSH3_POINT_EDGE_MIN )
#define psh3_point_is_edge_max( p ) ( (p)->flags2 & PSH3_POINT_EDGE_MAX )
#define psh3_point_set_strong( p ) (p)->flags2 |= PSH3_POINT_STRONG
#define psh3_point_set_fitted( p ) (p)->flags2 |= PSH3_POINT_FITTED
#define psh3_point_set_extremum( p ) (p)->flags2 |= PSH3_POINT_EXTREMUM
#define psh3_point_set_positive( p ) (p)->flags2 |= PSH3_POINT_POSITIVE
#define psh3_point_set_negative( p ) (p)->flags2 |= PSH3_POINT_NEGATIVE
#define psh3_point_set_edge_min( p ) (p)->flags2 |= PSH3_POINT_EDGE_MIN
#define psh3_point_set_edge_max( p ) (p)->flags2 |= PSH3_POINT_EDGE_MAX
typedef struct PSH3_PointRec_
{
PSH3_Point prev;
PSH3_Point next;
PSH3_Contour contour;
FT_UInt flags;
FT_UInt flags2;
FT_Char dir_in;
FT_Char dir_out;
FT_Angle angle_in;
FT_Angle angle_out;
PSH3_Hint hint;
FT_Pos org_u;
FT_Pos org_v;
FT_Pos cur_u;
#ifdef DEBUG_HINTER
FT_Pos org_x;
FT_Pos cur_x;
FT_Pos org_y;
FT_Pos cur_y;
FT_UInt flags_x;
FT_UInt flags_y;
#endif
} PSH3_PointRec;
#define PSH3_POINT_EQUAL_ORG( a, b ) ( (a)->org_u == (b)->org_u && \
(a)->org_v == (b)->org_v )
#define PSH3_POINT_ANGLE( a, b ) FT_Atan2( (b)->org_u - (a)->org_u, \
(b)->org_v - (a)->org_v )
typedef struct PSH3_ContourRec_
{
PSH3_Point start;
FT_UInt count;
} PSH3_ContourRec;
typedef struct PSH3_GlyphRec_
{
FT_UInt num_points;
FT_UInt num_contours;
PSH3_Point points;
PSH3_Contour contours;
FT_Memory memory;
FT_Outline* outline;
PSH_Globals globals;
PSH3_Hint_TableRec hint_tables[2];
FT_Bool vertical;
FT_Int major_dir;
FT_Int minor_dir;
FT_Bool do_horz_hints;
FT_Bool do_vert_hints;
FT_Bool do_horz_snapping;
FT_Bool do_vert_snapping;
FT_Bool do_stem_adjust;
} PSH3_GlyphRec, *PSH3_Glyph;
#ifdef DEBUG_HINTER
extern PSH3_Hint_Table ps3_debug_hint_table;
typedef void
(*PSH3_HintFunc)( PSH3_Hint hint,
FT_Bool vertical );
extern PSH3_HintFunc ps3_debug_hint_func;
extern PSH3_Glyph ps3_debug_glyph;
#endif
extern FT_Error
ps3_hints_apply( PS_Hints ps_hints,
FT_Outline* outline,
PSH_Globals globals,
FT_Render_Mode hint_mode );
FT_END_HEADER
#endif /* __PSHALGO3_H__ */
/* END */

6
src/pshinter/pshglob.c
View File

@ -5,7 +5,7 @@
/* PostScript hinter global hinting management (body). */
/* Inspired by the new auto-hinter module. */
/* */
/* Copyright 2001, 2002 by */
/* Copyright 2001, 2002, 2003 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used */
@ -78,6 +78,8 @@
}
#if 0
/* org_width is is font units, result in device pixels, 26.6 format */
FT_LOCAL_DEF( FT_Pos )
psh_dimension_snap_width( PSH_Dimension dimension,
@ -122,6 +124,8 @@
return width;
}
#endif /* 0 */
/*************************************************************************/
/*************************************************************************/

4
src/pshinter/pshglob.h
View File

@ -4,7 +4,7 @@
/* */
/* PostScript hinter global hinting management. */
/* */
/* Copyright 2001, 2002 by */
/* Copyright 2001, 2002, 2003 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -159,11 +159,13 @@ FT_BEGIN_HEADER
psh_globals_funcs_init( PSH_Globals_FuncsRec* funcs );
#if 0
/* snap a stem width to fitter coordinates. `org_width' is in font */
/* units. The result is in device pixels (26.6 format). */
FT_LOCAL( FT_Pos )
psh_dimension_snap_width( PSH_Dimension dimension,
FT_Int org_width );
#endif
/* snap a stem to one or two blue zones */
FT_LOCAL( void )

6
src/pshinter/pshinter.c
View File

@ -4,7 +4,7 @@
/* */
/* FreeType PostScript Hinting module */
/* */
/* Copyright 2001 by */
/* Copyright 2001, 2003 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -21,9 +21,7 @@
#include <ft2build.h>
#include "pshrec.c"
#include "pshglob.c"
#include "pshalgo1.c"
#include "pshalgo2.c"
#include "pshalgo3.c"
#include "pshalgo.c"
#include "pshmod.c"

6
src/pshinter/pshrec.c
View File

@ -4,7 +4,7 @@
/* */
/* FreeType PostScript hints recorder (body). */
/* */
/* Copyright 2001, 2002 by */
/* Copyright 2001, 2002, 2003 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -1139,7 +1139,7 @@
funcs->stem = (T1_Hints_SetStemFunc) t1_hints_stem;
funcs->stem3 = (T1_Hints_SetStem3Func)ps_hints_t1stem3;
funcs->reset = (T1_Hints_ResetFunc) ps_hints_t1reset;
funcs->apply = (T1_Hints_ApplyFunc) PS_HINTS_APPLY_FUNC;
funcs->apply = (T1_Hints_ApplyFunc) ps_hints_apply;
}
@ -1204,7 +1204,7 @@
funcs->stems = (T2_Hints_StemsFunc) t2_hints_stems;
funcs->hintmask= (T2_Hints_MaskFunc) ps_hints_t2mask;
funcs->counter = (T2_Hints_CounterFunc)ps_hints_t2counter;
funcs->apply = (T2_Hints_ApplyFunc) PS_HINTS_APPLY_FUNC;
funcs->apply = (T2_Hints_ApplyFunc) ps_hints_apply;
}

10
src/pshinter/rules.mk
View File

@ -26,12 +26,10 @@ PSHINTER_COMPILE := $(FT_COMPILE) $I$(PSHINTER_DIR)
# PSHINTER driver sources (i.e., C files)
#
PSHINTER_DRV_SRC := $(PSHINTER_DIR_)pshrec.c \
$(PSHINTER_DIR_)pshglob.c \
$(PSHINTER_DIR_)pshmod.c \
$(PSHINTER_DIR_)pshalgo1.c \
$(PSHINTER_DIR_)pshalgo2.c \
$(PSHINTER_DIR_)pshalgo3.c
PSHINTER_DRV_SRC := $(PSHINTER_DIR_)pshrec.c \
$(PSHINTER_DIR_)pshglob.c \
$(PSHINTER_DIR_)pshmod.c \
$(PSHINTER_DIR_)pshalgo.c
# PSHINTER driver headers

295
tests/gview.c
View File

@ -7,9 +7,7 @@
/* include FreeType internals to debug hints */
#include <../src/pshinter/pshrec.h>
#include <../src/pshinter/pshalgo1.h>
#include <../src/pshinter/pshalgo2.h>
#include <../src/pshinter/pshalgo3.h>
#include <../src/pshinter/pshalgo.h>
#include <../src/autohint/ahtypes.h>
@ -358,271 +356,20 @@ draw_ps_blue_zones( void )
}
}
/************************************************************************/
/************************************************************************/
/***** *****/
/***** POSTSCRIPT HINTER ALGORITHM 1 ROUTINES *****/
/***** POSTSCRIPT HINTER ALGORITHM ROUTINES *****/
/***** *****/
/************************************************************************/
/************************************************************************/
#include <../src/pshinter/pshalgo1.h>
static int pshint_cpos = 0;
static int pshint_vertical = -1;
#include <../src/pshinter/pshalgo.h>
static void
draw_ps1_hint( PSH1_Hint hint, FT_Bool vertical )
{
int x1, x2;
NV_Vector v;
if ( pshint_vertical != vertical )
{
if (vertical)
pshint_cpos = 40;
else
pshint_cpos = 10;
pshint_vertical = vertical;
}
if (vertical)
{
if ( !option_show_vert_hints )
return;
v.x = hint->cur_pos;
v.y = 0;
nv_vector_transform( &v, &size_transform );
x1 = (int)(v.x + 0.5);
v.x = hint->cur_pos + hint->cur_len;
v.y = 0;
nv_vector_transform( &v, &size_transform );
x2 = (int)(v.x + 0.5);
nv_pixmap_fill_rect( target, x1, 0, 1, target->height,
psh1_hint_is_ghost(hint)
? GHOST_HINT_COLOR : STEM_HINT_COLOR );
if ( psh1_hint_is_ghost(hint) )
{
x1 --;
x2 = x1 + 2;
}
else
nv_pixmap_fill_rect( target, x2, 0, 1, target->height,
psh1_hint_is_ghost(hint)
? GHOST_HINT_COLOR : STEM_HINT_COLOR );
nv_pixmap_fill_rect( target, x1, pshint_cpos, x2+1-x1, 1,
STEM_JOIN_COLOR );
}
else
{
if (!option_show_horz_hints)
return;
v.y = hint->cur_pos;
v.x = 0;
nv_vector_transform( &v, &size_transform );
x1 = (int)(v.y + 0.5);
v.y = hint->cur_pos + hint->cur_len;
v.x = 0;
nv_vector_transform( &v, &size_transform );
x2 = (int)(v.y + 0.5);
nv_pixmap_fill_rect( target, 0, x1, target->width, 1,
psh1_hint_is_ghost(hint)
? GHOST_HINT_COLOR : STEM_HINT_COLOR );
if ( psh1_hint_is_ghost(hint) )
{
x1 --;
x2 = x1 + 2;
}
else
nv_pixmap_fill_rect( target, 0, x2, target->width, 1,
psh1_hint_is_ghost(hint)
? GHOST_HINT_COLOR : STEM_HINT_COLOR );
nv_pixmap_fill_rect( target, pshint_cpos, x2, 1, x1+1-x2,
STEM_JOIN_COLOR );
}
#if 0
printf( "[%7.3f %7.3f] %c\n", hint->cur_pos/64.0, (hint->cur_pos+hint->cur_len)/64.0, vertical ? 'v' : 'h' );
#endif
pshint_cpos += 10;
}
/************************************************************************/
/************************************************************************/
/***** *****/
/***** POSTSCRIPT HINTER ALGORITHM 2 ROUTINES *****/
/***** *****/
/************************************************************************/
/************************************************************************/
#include <../src/pshinter/pshalgo2.h>
static void
draw_ps2_hint( PSH2_Hint hint, FT_Bool vertical )
{
int x1, x2;
NV_Vector v;
if ( pshint_vertical != vertical )
{
if (vertical)
pshint_cpos = 40;
else
pshint_cpos = 10;
pshint_vertical = vertical;
}
if (vertical)
{
if ( !option_show_vert_hints )
return;
v.x = hint->cur_pos;
v.y = 0;
nv_vector_transform( &v, &size_transform );
x1 = (int)(v.x + 0.5);
v.x = hint->cur_pos + hint->cur_len;
v.y = 0;
nv_vector_transform( &v, &size_transform );
x2 = (int)(v.x + 0.5);
nv_pixmap_fill_rect( target, x1, 0, 1, target->height,
psh2_hint_is_ghost(hint)
? GHOST_HINT_COLOR : STEM_HINT_COLOR );
if ( psh2_hint_is_ghost(hint) )
{
x1 --;
x2 = x1 + 2;
}
else
nv_pixmap_fill_rect( target, x2, 0, 1, target->height,
psh2_hint_is_ghost(hint)
? GHOST_HINT_COLOR : STEM_HINT_COLOR );
nv_pixmap_fill_rect( target, x1, pshint_cpos, x2+1-x1, 1,
STEM_JOIN_COLOR );
}
else
{
if (!option_show_horz_hints)
return;
v.y = hint->cur_pos;
v.x = 0;
nv_vector_transform( &v, &size_transform );
x1 = (int)(v.y + 0.5);
v.y = hint->cur_pos + hint->cur_len;
v.x = 0;
nv_vector_transform( &v, &size_transform );
x2 = (int)(v.y + 0.5);
nv_pixmap_fill_rect( target, 0, x1, target->width, 1,
psh2_hint_is_ghost(hint)
? GHOST_HINT_COLOR : STEM_HINT_COLOR );
if ( psh2_hint_is_ghost(hint) )
{
x1 --;
x2 = x1 + 2;
}
else
nv_pixmap_fill_rect( target, 0, x2, target->width, 1,
psh2_hint_is_ghost(hint)
? GHOST_HINT_COLOR : STEM_HINT_COLOR );
nv_pixmap_fill_rect( target, pshint_cpos, x2, 1, x1+1-x2,
STEM_JOIN_COLOR );
}
#if 0
printf( "[%7.3f %7.3f] %c\n", hint->cur_pos/64.0, (hint->cur_pos+hint->cur_len)/64.0, vertical ? 'v' : 'h' );
#endif
pshint_cpos += 10;
}
static void
ps2_draw_control_points( void )
{
if ( ps2_debug_glyph )
{
PSH2_Glyph glyph = ps2_debug_glyph;
PSH2_Point point = glyph->points;
FT_UInt count = glyph->num_points;
NV_Transform transform, *trans = &transform;
NV_Path vert_rect;
NV_Path horz_rect;
NV_Path dot, circle;
for ( ; count > 0; count--, point++ )
{
NV_Vector vec;
vec.x = point->cur_x;
vec.y = point->cur_y;
nv_vector_transform( &vec, &size_transform );
nv_transform_set_translate( trans, vec.x, vec.y );
if ( option_show_smooth && !psh2_point_is_smooth(point) )
{
nv_painter_set_color( painter, SMOOTH_COLOR, 256 );
nv_painter_fill_path( painter, trans, 0, symbol_circle );
}
if (option_show_horz_hints)
{
if ( point->flags_y & PSH2_POINT_STRONG )
{
nv_painter_set_color( painter, STRONG_COLOR, 256 );
nv_painter_fill_path( painter, trans, 0, symbol_rect_h );
}
}
if (option_show_vert_hints)
{
if ( point->flags_x & PSH2_POINT_STRONG )
{
nv_painter_set_color( painter, STRONG_COLOR, 256 );
nv_painter_fill_path( painter, trans, 0, symbol_rect_v );
}
}
}
}
}
/************************************************************************/
/************************************************************************/
/***** *****/
/***** POSTSCRIPT HINTER ALGORITHM 3 ROUTINES *****/
/***** *****/
/************************************************************************/
/************************************************************************/
#include <../src/pshinter/pshalgo3.h>
static void
draw_ps3_hint( PSH3_Hint hint, FT_Bool vertical )
draw_ps_hint( PSH_Hint hint,
FT_Bool vertical )
{
int x1, x2;
NV_Vector v;
@ -653,17 +400,17 @@ draw_ps3_hint( PSH3_Hint hint, FT_Bool vertical )
x2 = (int)(v.x + 0.5);
nv_pixmap_fill_rect( target, x1, 0, 1, target->height,
psh3_hint_is_ghost(hint)
psh_hint_is_ghost( hint )
? GHOST_HINT_COLOR : STEM_HINT_COLOR );
if ( psh3_hint_is_ghost(hint) )
if ( psh_hint_is_ghost( hint ) )
{
x1 --;
x2 = x1 + 2;
}
else
nv_pixmap_fill_rect( target, x2, 0, 1, target->height,
psh3_hint_is_ghost(hint)
psh_hint_is_ghost( hint )
? GHOST_HINT_COLOR : STEM_HINT_COLOR );
nv_pixmap_fill_rect( target, x1, pshint_cpos, x2+1-x1, 1,
@ -685,17 +432,17 @@ draw_ps3_hint( PSH3_Hint hint, FT_Bool vertical )
x2 = (int)(v.y + 0.5);
nv_pixmap_fill_rect( target, 0, x1, target->width, 1,
psh3_hint_is_ghost(hint)
psh_hint_is_ghost( hint )
? GHOST_HINT_COLOR : STEM_HINT_COLOR );
if ( psh3_hint_is_ghost(hint) )
if ( psh_hint_is_ghost(hint) )
{
x1 --;
x2 = x1 + 2;
}
else
nv_pixmap_fill_rect( target, 0, x2, target->width, 1,
psh3_hint_is_ghost(hint)
psh_hint_is_ghost(hint)
? GHOST_HINT_COLOR : STEM_HINT_COLOR );
nv_pixmap_fill_rect( target, pshint_cpos, x2, 1, x1+1-x2,
@ -711,12 +458,12 @@ draw_ps3_hint( PSH3_Hint hint, FT_Bool vertical )
static void
ps3_draw_control_points( void )
ps_draw_control_points( void )
{
if ( ps3_debug_glyph )
if ( ps_debug_glyph )
{
PSH3_Glyph glyph = ps3_debug_glyph;
PSH3_Point point = glyph->points;
PSH_Glyph glyph = ps_debug_glyph;
PSH_Point point = glyph->points;
FT_UInt count = glyph->num_points;
NV_Transform transform, *trans = &transform;
NV_Path vert_rect;
@ -733,7 +480,7 @@ ps3_draw_control_points( void )
nv_transform_set_translate( trans, vec.x, vec.y );
if ( option_show_smooth && !psh3_point_is_smooth(point) )
if ( option_show_smooth && !psh_point_is_smooth(point) )
{
nv_painter_set_color( painter, SMOOTH_COLOR, 256 );
nv_painter_fill_path( painter, trans, 0, symbol_circle );
@ -741,7 +488,7 @@ ps3_draw_control_points( void )
if (option_show_horz_hints)
{
if ( point->flags_y & PSH3_POINT_STRONG )
if ( point->flags_y & PSH_POINT_STRONG )
{
nv_painter_set_color( painter, STRONG_COLOR, 256 );
nv_painter_fill_path( painter, trans, 0, symbol_rect_h );
@ -750,7 +497,7 @@ ps3_draw_control_points( void )
if (option_show_vert_hints)
{
if ( point->flags_x & PSH3_POINT_STRONG )
if ( point->flags_x & PSH_POINT_STRONG )
{
nv_painter_set_color( painter, STRONG_COLOR, 256 );
nv_painter_fill_path( painter, trans, 0, symbol_rect_v );
@ -1104,9 +851,7 @@ draw_glyph( int glyph_index )
pshint_vertical = -1;
ps1_debug_hint_func = option_show_ps_hints ? draw_ps1_hint : 0;
ps2_debug_hint_func = option_show_ps_hints ? draw_ps2_hint : 0;
ps3_debug_hint_func = option_show_ps_hints ? draw_ps3_hint : 0;
ps_debug_hint_func = option_show_ps_hints ? draw_ps_hint : 0;
ah_debug_hinter = NULL;