stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8057986: freetype code to get glyph outline does not handle initial control point properly

Browse Source 
Co-authored-by: Igor Kopylov <ikopylov@google.com>
Reviewed-by: prr, dougfelt
This commit is contained in:
Behdad Esfahbod 2014-09-05 19:06:07 -07:00 committed by Martin Buchholz
parent acba04a5b8
commit c29aa1d7b9
2 changed files with 143 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

130
jdk/src/java.desktop/share/native/libfontmanager/freetypeScaler.c
View File

@ -1082,86 +1082,60 @@ static int allocateSpaceForGP(GPData* gpdata, int npoints, int ncontours) {
return 1;
}
static void addSeg(GPData *gp, jbyte type) {
gp->pointTypes[gp->numTypes++] = type;
}
static void addCoords(GPData *gp, FT_Vector *p) {
gp->pointCoords[gp->numCoords++] = F26Dot6ToFloat(p->x);
gp->pointCoords[gp->numCoords++] = -F26Dot6ToFloat(p->y);
}
static int moveTo(FT_Vector *to, GPData *gp) {
if (gp->numCoords)
addSeg(gp, SEG_CLOSE);
addCoords(gp, to);
addSeg(gp, SEG_MOVETO);
return FT_Err_Ok;
}
static int lineTo(FT_Vector *to, GPData *gp) {
addCoords(gp, to);
addSeg(gp, SEG_LINETO);
return FT_Err_Ok;
}
static int conicTo(FT_Vector *control, FT_Vector *to, GPData *gp) {
addCoords(gp, control);
addCoords(gp, to);
addSeg(gp, SEG_QUADTO);
return FT_Err_Ok;
}
static int cubicTo(FT_Vector *control1,
FT_Vector *control2,
FT_Vector *to,
GPData *gp) {
addCoords(gp, control1);
addCoords(gp, control2);
addCoords(gp, to);
addSeg(gp, SEG_CUBICTO);
return FT_Err_Ok;
}
static void addToGP(GPData* gpdata, FT_Outline*outline) {
jbyte current_type=SEG_UNKNOWN;
int i, j;
jfloat x, y;
static const FT_Outline_Funcs outline_funcs = {
(FT_Outline_MoveToFunc) moveTo,
(FT_Outline_LineToFunc) lineTo,
(FT_Outline_ConicToFunc) conicTo,
(FT_Outline_CubicToFunc) cubicTo,
0, /* shift */
0, /* delta */
};
j = 0;
for(i=0; i<outline->n_points; i++) {
x = F26Dot6ToFloat(outline->points[i].x);
y = -F26Dot6ToFloat(outline->points[i].y);
if (FT_CURVE_TAG(outline->tags[i]) == FT_CURVE_TAG_ON) {
/* If bit 0 is unset, the point is "off" the curve,
i.e., a Bezier control point, while it is "on" when set. */
if (current_type == SEG_UNKNOWN) { /* special case:
very first point */
/* add segment */
gpdata->pointTypes[gpdata->numTypes++] = SEG_MOVETO;
current_type = SEG_LINETO;
} else {
gpdata->pointTypes[gpdata->numTypes++] = current_type;
current_type = SEG_LINETO;
}
} else {
if (current_type == SEG_UNKNOWN) { /* special case:
very first point */
if (FT_CURVE_TAG(outline->tags[i+1]) == FT_CURVE_TAG_ON) {
/* just skip first point. Adhoc heuristic? */
continue;
} else {
x = (x + F26Dot6ToFloat(outline->points[i+1].x))/2;
y = (y - F26Dot6ToFloat(outline->points[i+1].y))/2;
gpdata->pointTypes[gpdata->numTypes++] = SEG_MOVETO;
current_type = SEG_LINETO;
}
} else if (FT_CURVE_TAG(outline->tags[i]) == FT_CURVE_TAG_CUBIC) {
/* Bit 1 is meaningful for 'off' points only.
If set, it indicates a third-order Bezier arc control
point; and a second-order control point if unset. */
current_type = SEG_CUBICTO;
} else {
/* two successive conic "off" points forces the rasterizer
to create (during the scan-line conversion process
exclusively) a virtual "on" point amidst them, at their
exact middle. This greatly facilitates the definition of
successive conic Bezier arcs. Moreover, it is the way
outlines are described in the TrueType specification. */
if (current_type == SEG_QUADTO) {
gpdata->pointCoords[gpdata->numCoords++] =
F26Dot6ToFloat(outline->points[i].x +
outline->points[i-1].x)/2;
gpdata->pointCoords[gpdata->numCoords++] =
- F26Dot6ToFloat(outline->points[i].y +
outline->points[i-1].y)/2;
gpdata->pointTypes[gpdata->numTypes++] = SEG_QUADTO;
}
current_type = SEG_QUADTO;
}
}
gpdata->pointCoords[gpdata->numCoords++] = x;
gpdata->pointCoords[gpdata->numCoords++] = y;
if (outline->contours[j] == i) { //end of contour
int start = j > 0 ? outline->contours[j-1]+1 : 0;
gpdata->pointTypes[gpdata->numTypes++] = current_type;
if (current_type == SEG_QUADTO &&
FT_CURVE_TAG(outline->tags[start]) != FT_CURVE_TAG_ON) {
gpdata->pointCoords[gpdata->numCoords++] =
(F26Dot6ToFloat(outline->points[start].x) + x)/2;
gpdata->pointCoords[gpdata->numCoords++] =
(-F26Dot6ToFloat(outline->points[start].y) + y)/2;
} else {
gpdata->pointCoords[gpdata->numCoords++] =
F26Dot6ToFloat(outline->points[start].x);
gpdata->pointCoords[gpdata->numCoords++] =
-F26Dot6ToFloat(outline->points[start].y);
}
gpdata->pointTypes[gpdata->numTypes++] = SEG_CLOSE;
current_type = SEG_UNKNOWN;
j++;
}
}
FT_Outline_Decompose(outline, &outline_funcs, gpdata);
if (gpdata->numCoords)
addSeg(gpdata, SEG_CLOSE);
/* If set to 1, the outline will be filled using the even-odd fill rule */
if (outline->flags & FT_OUTLINE_EVEN_ODD_FILL) {

91
jdk/test/java/awt/font/GlyphVector/GlyphVectorOutline.java Normal file
View File

@ -0,0 +1,91 @@
/*
* Copyright (c) 2014 Google Inc. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.font.FontRenderContext;
import java.awt.font.GlyphVector;
import java.awt.font.LineBreakMeasurer;
import java.awt.font.TextAttribute;
import java.awt.font.TextLayout;
import java.awt.image.BufferedImage;
import java.io.File;
import java.text.AttributedString;
import javax.imageio.ImageIO;
/**
* Manual test for:
* JDK-8057986: freetype code to get glyph outline does not handle initial control point properly
*
* Manual repro recipe:
* (cd test/java/awt/font/GlyphVector/ && javac GlyphVectorOutline.java && wget -q -O/tmp/msgothic.ttc https://browserlinux-jp.googlecode.com/files/msgothic.ttc && java GlyphVectorOutline /tmp/msgothic.ttc /tmp/katakana.png)
*
* Then examine the two rendered Japanese characters in the png file.
*
* Renders text to a PNG by
* 1. using the native Graphics2D#drawGlyphVector implementation
* 2. filling in the result of GlyphVector#getOutline
*
* Should be the same but is different for some CJK characters
* (e.g. Katakana character \u30AF).
*
* @author ikopylov@google.com (Igor Kopylov)
*/
public class GlyphVectorOutline {
public static void main(String[] args) throws Exception {
if (args.length != 2) {
throw new Error("Usage: java GlyphVectorOutline fontfile outputfile");
}
writeImage(new File(args[0]),
new File(args[1]),
"\u30AF");
}
public static void writeImage(File fontFile, File outputFile, String value) throws Exception {
BufferedImage image = new BufferedImage(200, 200, BufferedImage.TYPE_INT_RGB);
Graphics2D g = image.createGraphics();
g.setColor(Color.WHITE);
g.fillRect(0, 0, image.getWidth(), image.getHeight());
g.setColor(Color.BLACK);
Font font = Font.createFont(Font.TRUETYPE_FONT, fontFile);
font = font.deriveFont(Font.PLAIN, 72f);
FontRenderContext frc = new FontRenderContext(null, false, false);
GlyphVector gv = font.createGlyphVector(frc, value);
g.drawGlyphVector(gv, 10, 80);
g.fill(gv.getOutline(10, 180));
ImageIO.write(image, "png", outputFile);
}
private static void drawString(Graphics2D g, Font font, String value, float x, float y) {
AttributedString str = new AttributedString(value);
str.addAttribute(TextAttribute.FOREGROUND, Color.BLACK);
str.addAttribute(TextAttribute.FONT, font);
FontRenderContext frc = new FontRenderContext(null, true, true);
TextLayout layout = new LineBreakMeasurer(str.getIterator(), frc).nextLayout(Integer.MAX_VALUE);
layout.draw(g, x, y);
}
}