You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@pdfbox.apache.org by le...@apache.org on 2012/05/20 12:06:06 UTC
svn commit: r1340655 -
/pdfbox/trunk/fontbox/src/main/java/org/apache/fontbox/ttf/Glyph2D.java
Author: lehmi
Date: Sun May 20 10:06:05 2012
New Revision: 1340655
URL: http://svn.apache.org/viewvc?rev=1340655&view=rev
Log:
PDFBOX-490: added a class to convert a TTF-glyph into an AWT-GeneralPath based on Apache Batik code
Added:
pdfbox/trunk/fontbox/src/main/java/org/apache/fontbox/ttf/Glyph2D.java
Added: pdfbox/trunk/fontbox/src/main/java/org/apache/fontbox/ttf/Glyph2D.java
URL: http://svn.apache.org/viewvc/pdfbox/trunk/fontbox/src/main/java/org/apache/fontbox/ttf/Glyph2D.java?rev=1340655&view=auto
==============================================================================
--- pdfbox/trunk/fontbox/src/main/java/org/apache/fontbox/ttf/Glyph2D.java (added)
+++ pdfbox/trunk/fontbox/src/main/java/org/apache/fontbox/ttf/Glyph2D.java Sun May 20 10:06:05 2012
@@ -0,0 +1,252 @@
+/*
+
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements. See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+ */
+package org.apache.fontbox.ttf;
+
+import java.awt.geom.GeneralPath;
+import java.awt.geom.Point2D;
+
+
+/**
+ * This class provides a glyph to GeneralPath conversion.
+ *
+ * This class is based on code from Apache Batik a subproject of Apache XMLGraphics.
+ * see http://xmlgraphics.apache.org/batik/ for further details.
+ */
+public class Glyph2D
+{
+
+ private short leftSideBearing = 0;
+ private int advanceWidth = 0;
+ private Point[] points;
+ private GeneralPath glyphPath;
+
+ /**
+ * Constructor.
+ *
+ * @param gd the glyph description
+ * @param lsb leftSideBearing
+ * @param advance advanceWidth
+ */
+ public Glyph2D(GlyphDescription gd, short lsb, int advance)
+ {
+ leftSideBearing = lsb;
+ advanceWidth = advance;
+ describe(gd);
+ }
+
+ /**
+ * Returns the advanceWidth value.
+ *
+ * @return the advanceWidth
+ */
+ public int getAdvanceWidth()
+ {
+ return advanceWidth;
+ }
+
+ /**
+ * Returns the leftSideBearing value.
+ *
+ * @return the leftSideBearing
+ */
+ public short getLeftSideBearing()
+ {
+ return leftSideBearing;
+ }
+
+ /**
+ * Set the points of a glyph from the GlyphDescription.
+ */
+ private void describe(GlyphDescription gd)
+ {
+ int endPtIndex = 0;
+ points = new Point[gd.getPointCount()];
+ for (int i = 0; i < gd.getPointCount(); i++)
+ {
+ boolean endPt = gd.getEndPtOfContours(endPtIndex) == i;
+ if (endPt)
+ {
+ endPtIndex++;
+ }
+ points[i] = new Point(
+ gd.getXCoordinate(i),
+ gd.getYCoordinate(i),
+ (gd.getFlags(i) & GlyfDescript.ON_CURVE) != 0,
+ endPt);
+ }
+ }
+
+ /**
+ * Returns the path describing the glyph.
+ *
+ * @return the GeneralPath of the glyph
+ */
+ public GeneralPath getPath()
+ {
+ if (glyphPath == null)
+ {
+ glyphPath = calculatePath();
+ }
+ return glyphPath;
+ }
+
+ private GeneralPath calculatePath()
+ {
+ GeneralPath path = new GeneralPath();
+ int numberOfPoints = points.length;
+ int i=0;
+ boolean endOfContour = true;
+ Point startingPoint = null;
+ Point lastCtrlPoint = null;
+ while (i < numberOfPoints)
+ {
+ Point point = points[i%numberOfPoints];
+ Point nextPoint1 = points[(i+1)%numberOfPoints];
+ Point nextPoint2 = points[(i+2)%numberOfPoints];
+ // new contour
+ if (endOfContour)
+ {
+ // skip endOfContour points
+ if (point.endOfContour)
+ {
+ i++;
+ continue;
+ }
+ // move to the starting point
+ path.moveTo(point.x, point.y);
+ endOfContour = false;
+ startingPoint = point;
+ }
+ // lineTo
+ if (point.onCurve && nextPoint1.onCurve)
+ {
+ path.lineTo(nextPoint1.x, nextPoint1.y);
+ i++;
+ if (point.endOfContour || nextPoint1.endOfContour)
+ {
+ endOfContour = true;
+ path.closePath();
+ }
+ continue;
+ }
+ // quadratic bezier
+ if (point.onCurve && !nextPoint1.onCurve && nextPoint2.onCurve)
+ {
+ if (nextPoint1.endOfContour)
+ {
+ // use the starting point as end point
+ path.quadTo(nextPoint1.x, nextPoint1.y, startingPoint.x, startingPoint.y);
+ }
+ else
+ {
+ path.quadTo(nextPoint1.x, nextPoint1.y, nextPoint2.x, nextPoint2.y);
+ }
+ if (nextPoint1.endOfContour || nextPoint2.endOfContour)
+ {
+ endOfContour = true;
+ path.closePath();
+ }
+ i+=2;
+ lastCtrlPoint = nextPoint1;
+ continue;
+ }
+ if (point.onCurve && !nextPoint1.onCurve && !nextPoint2.onCurve)
+ {
+ // interpolate endPoint
+ int endPointX = midValue(nextPoint1.x, nextPoint2.x);
+ int endPointY = midValue(nextPoint1.y, nextPoint2.y);
+ path.quadTo(nextPoint1.x, nextPoint1.y, endPointX, endPointY);
+ if (point.endOfContour || nextPoint1.endOfContour || nextPoint2.endOfContour)
+ {
+ path.quadTo(nextPoint2.x, nextPoint2.y, startingPoint.x, startingPoint.y);
+ endOfContour = true;
+ path.closePath();
+ }
+ i+=2;
+ lastCtrlPoint = nextPoint1;
+ continue;
+ }
+ if (!point.onCurve && !nextPoint1.onCurve)
+ {
+ Point2D lastEndPoint = path.getCurrentPoint();
+ // calculate new control point using the previous control point
+ lastCtrlPoint = new Point(midValue(lastCtrlPoint.x, (int)lastEndPoint.getX()),
+ midValue(lastCtrlPoint.y, (int)lastEndPoint.getY()));
+ // interpolate endPoint
+ int endPointX = midValue((int)lastEndPoint.getX(), nextPoint1.x);
+ int endPointY = midValue((int)lastEndPoint.getY(), nextPoint1.y);
+ path.quadTo(lastCtrlPoint.x, lastCtrlPoint.y, endPointX, endPointY);
+ if (point.endOfContour || nextPoint1.endOfContour)
+ {
+ endOfContour = true;
+ path.closePath();
+ }
+ i++;
+ continue;
+ }
+ if (!point.onCurve && nextPoint1.onCurve)
+ {
+ path.quadTo(point.x, point.y, nextPoint1.x, nextPoint1.y);
+ if (point.endOfContour || nextPoint1.endOfContour)
+ {
+ endOfContour = true;
+ path.closePath();
+ }
+ i++;
+ lastCtrlPoint = point;
+ continue;
+ }
+ System.err.println("Unknown glyph command!!");
+ break;
+ }
+ return path;
+ }
+
+ private int midValue(int a, int b)
+ {
+ return a + (b - a)/2;
+ }
+
+ /**
+ * This class represents one point of a glyph.
+ *
+ */
+ private class Point
+ {
+
+ public int x = 0;
+ public int y = 0;
+ public boolean onCurve = true;
+ public boolean endOfContour = false;
+
+ public Point(int xValue, int yValue, boolean onCurveValue, boolean endOfContourValue)
+ {
+ x = xValue;
+ y = yValue;
+ onCurve = onCurveValue;
+ endOfContour = endOfContourValue;
+ }
+
+ public Point(int xValue, int yValue)
+ {
+ this(xValue, yValue, false, false);
+ }
+ }
+
+}