path: root/libjava/classpath/gnu/java/awt/font/autofit/GlyphHints.java

/* GlyphHints.java -- Data and methods for actual hinting
   Copyright (C) 2006 Free Software Foundation, Inc.

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.

Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.

As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */


package gnu.java.awt.font.autofit;

import gnu.java.awt.font.FontDelegate;
import gnu.java.awt.font.opentype.truetype.Fixed;
import gnu.java.awt.font.opentype.truetype.Point;
import gnu.java.awt.font.opentype.truetype.Zone;

/**
 * The data and methods used for the actual hinting process.
 */
class GlyphHints
  implements Constants
{

  int xScale;
  int xDelta;
  int yScale;
  int yDelta;

  AxisHints[] axis;

  Point[] points;
  int numPoints;
  int maxPoints;

  Point[] contours;
  int numContours;
  int maxContours;

  ScriptMetrics metrics;

  int flags;

  GlyphHints()
  {
    axis = new AxisHints[Constants.DIMENSION_MAX];
    axis[Constants.DIMENSION_VERT] = new AxisHints();
    axis[Constants.DIMENSION_HORZ] = new AxisHints();

    xScale = Fixed.ONE;
    yScale = Fixed.ONE;
  }

  void rescale(ScriptMetrics m)
  {
    metrics = m;
    // TODO: Copy scalerFlags.
  }

  void reload(Zone outline)
  {
    numPoints = 0;
    numContours = 0;
    axis[0].numSegments = 0;
    axis[0].numEdges = 0;
    axis[1].numSegments = 0;
    axis[1].numEdges = 0;

    // Create/reallocate the contours array.
    int newMax = outline.getNumContours();
    if (newMax > maxContours || contours == null)
      {
        newMax = (newMax + 3) & ~3; // Taken from afhints.c .
        Point[] newContours = new Point[newMax];
        if (contours != null)
          {
            System.arraycopy(contours, 0, newContours, 0, maxContours);
          }
        contours = newContours;
        maxContours = newMax;
      }

    // Create/reallocate the points array.
    newMax = outline.getSize() + 2;
    if (newMax > maxPoints || points == null)
      {
        newMax = (newMax + 2 + 7) & ~7; // Taken from afhints.c .
        Point[] newPoints = new Point[newMax];
        if (points != null)
          {
            System.arraycopy(points, 0, newPoints, 0, maxPoints);
          }
        points = newPoints;
        maxPoints = newMax;
      }

    numPoints = outline.getSize() - 4; // 4 phantom points.
    numContours = outline.getNumContours();

    // Set major direction. We don't handle Type 1 fonts yet.
    axis[DIMENSION_HORZ].majorDir = DIR_UP;
    axis[DIMENSION_VERT].majorDir = DIR_LEFT;

    // TODO: Freetype seems to scale and translate the glyph at that point.
    // I suppose that this is not really needed.
    // The scales are scaling from font units to 1/64 device pixels.
    xScale = Fixed.valueOf16(outline.scaleX * 64);
    yScale = Fixed.valueOf16(outline.scaleY * 64);

    // FIXME: What is that xDelta and yDelta used for?
    System.arraycopy(outline.getPoints(), 0, points, 0, numPoints);

    // Setup prev and next and contours array.
    // TODO: Probably cache this.
    contours = new Point[numContours];
    Point currentContour = points[0];
    for (int i = 0, cIndex = 0; i < numPoints; i++)
      {
        // Start new contour when the last point has been a contour end.
        if (outline.isContourEnd(i))
          {
            // Connect the contour end point to the start point.
            points[i].setNext(currentContour);
            currentContour.setPrev(points[i]);
            contours[cIndex] = currentContour;
            cIndex++;
            currentContour = i < numPoints - 1 ? points[i + 1] : null;
          }
        else
          {
            // Connect the current and the previous point.
            points[i].setNext(points[i + 1]);
            points[i + 1].setPrev(points[i]);
          }
      }
    // Compute directions of in and out vectors of all points as well
    // as the weak point flag.
    for (int i = 0; i < numPoints; i++)
      {
        // Compute in and out dir.
        Point p = points[i];
        Point prev = p.getPrev();
        int inX = p.getOrigX() - prev.getOrigX();
        int inY = p.getOrigY() - prev.getOrigY();
        p.setInDir(Utils.computeDirection(inX, inY));
        Point next = p.getNext();
        int outX = next.getOrigX() - p.getOrigX();
        int outY = next.getOrigY() - p.getOrigY();
        p.setOutDir(Utils.computeDirection(outX, outY));

        if (p.isControlPoint())
          {
            setWeakPoint(p);
          }
        else if (p.getOutDir() == p.getInDir())
          {
            if (p.getOutDir() != DIR_NONE)
              setWeakPoint(p);
            else
              {
                int angleIn = Utils.atan(inY, inX);
                int angleOut = Utils.atan(outY, outX);
                int delta = Utils.angleDiff(angleIn, angleOut);
                if (delta < 2 && delta > -2)
                  setWeakPoint(p);
              }
          }
        else if (p.getInDir() == - p.getOutDir())
          {
            setWeakPoint(p);
          }
      }
    computeInflectionPoints();
  }

  private void setWeakPoint(Point p)
  {
    p.setFlags((byte) (p.getFlags() | Point.FLAG_WEAK_INTERPOLATION));
  }

  /**
   * Computes the inflection points for a glyph.
   */
  private void computeInflectionPoints()
  {
    // Do each contour separately.
    contours : for (int c = 0; c < contours.length; c++)
      {
        Point point = contours[c];
        Point first = point;
        Point start = point;
        Point end = point;
        do
          {
            end = end.getNext();
            if (end == first)
              continue contours;
          } while (end.getOrigX() == first.getOrigX()
                   && end.getOrigY() == first.getOrigY());

        // Extend segment start whenever possible.
        Point before = start;
        int angleIn;
        int angleSeg = Utils.atan(end.getOrigX() - start.getOrigX(),
                                  end.getOrigY() - start.getOrigY());
        do
          {
            do
              {
                start = before;
                before = before.getPrev();
                if (before == first)
                  continue contours;
              } while (before.getOrigX() == start.getOrigX()
                       && before.getOrigY() == start.getOrigY());
            angleIn = Utils.atan(start.getOrigX() - before.getOrigX(),
                                 start.getOrigY() - before.getOrigY());
          } while (angleIn == angleSeg);

        first = start;
        int diffIn = Utils.angleDiff(angleIn, angleSeg);
        // Now, process all segments in the contour.
        Point after;
        boolean finished = false;
        int angleOut, diffOut;
        do
          {
            // First, extend the current segment's end whenever possible.
            after = end;
            do
              {
                do
                  {
                    end = after;
                    after = after.getNext();
                    if (after == first)
                      finished = true;
                  } while (end.getOrigX() == after.getOrigX()
                           && end.getOrigY() == after.getOrigY());
                angleOut = Utils.atan(after.getOrigX() - end.getOrigX(),
                                      after.getOrigY() - end.getOrigY());
              } while (angleOut == angleSeg);
            diffOut = Utils.angleDiff(angleSeg, angleOut);
            if ((diffIn ^ diffOut) < 0)
              {
                // diffIn and diffOut have different signs, we have
                // inflection points here.
                do
                  {
                    start.addFlags(Point.FLAG_INFLECTION);
                    start = start.getNext();
                  } while (start != end);
                start.addFlags(Point.FLAG_INFLECTION);
              }
            start = end;
            end = after;
            angleSeg = angleOut;
            diffIn = diffOut;
          } while (! finished);
      }
  }

  boolean doHorizontal()
  {
    return (flags & FontDelegate.FLAG_NO_HINT_HORIZONTAL) == 0;
  }

  boolean doVertical()
  {
    return (flags & FontDelegate.FLAG_NO_HINT_VERTICAL) == 0;
  }

  void alignWeakPoints(int dim)
  {
    short touchFlag;
    Point point;
    // PASS 1 : Move segments to edge positions.
    if (dim == DIMENSION_HORZ)
      {
        touchFlag = Point.FLAG_DONE_X;
        for (int p = 0; p < numPoints; p++)
          {
            point = points[p];
            point.setU(point.getX());
            point.setV(point.getScaledX());
          }
      }
    else
      {
        touchFlag = Point.FLAG_DONE_Y;
        for (int p = 0; p < numPoints; p++)
          {
            point = points[p];
            point.setU(point.getY());
            point.setV(point.getScaledY());
          }
      }
    point = points[0];
    for (int c = 0; c < numContours; c++)
      {
        point = contours[c];
        int idx = getPointIndex(point);
        Point endPoint = point.getPrev();
        int endIdx = getPointIndex(endPoint);
        int firstIdx = idx;
        while (idx <=  endIdx
            && (point.getFlags() & touchFlag) == 0)
          {
            idx++;
            point = points[idx];
          }
        if (idx <= endIdx)
          {
            int firstTouched = idx;
            int curTouched = idx;
            idx++;
            point = points[idx];
            while (idx <= endIdx)
              {
                if ((point.getFlags() & touchFlag) != 0)
                  {
                    // We found two successive touch points. We interpolate
                    // all contour points between them.
                    iupInterp(curTouched + 1, idx - 1, curTouched, idx);
                    curTouched = idx;
                  }
                idx++;
                point = points[idx];
              }
            if (curTouched == firstTouched)
              {
                // This is a special case: Only one point was touched in the
                // contour. We thus simply shift the whole contour.
                iupShift(firstIdx, endIdx, curTouched);
              }
            else
              {
                // Now interpolate after the last touched point to the end
                // of the contour.
                iupInterp(curTouched + 1, endIdx, curTouched, firstTouched);
                // If the first contour point isn't touched, interpolate
                // from the contour start to the first touched point.
                if (firstTouched > 0)
                  {
                    iupInterp(firstIdx, firstTouched - 1, curTouched,
                              firstTouched);
                  }
              }
          }
      }
    // Now store the values back.
    if (dim == DIMENSION_HORZ)
      {
        for (int p = 0; p < numPoints; p++)
          {
            point = points[p];
            point.setX(point.getU());
          }
      }
    else
      {
        for (int p = 0; p < numPoints; p++)
          {
            point = points[p];
            point.setY(point.getU());
          }
      }
  }

  private void iupShift(int p1, int p2, int ref)
  {
    int delta = points[ref].getU() - points[ref].getV();
    for (int p = p1; p < ref; p++)
      {
        points[p].setU(points[p].getV() + delta);
      }
    for (int p = ref + 1; p <= p2; p++)
      {
        points[p].setU(points[p].getV() + delta);
      }
  }

  private void iupInterp(int p1, int p2, int ref1, int ref2)
  {
    int v1 = points[ref1].getV();
    int v2 = points[ref2].getV();
    int d1 = points[ref1].getU() - v1;
    int d2 = points[ref2].getU() - v2;
    if (p1 > p2)
      return;
    if (v1 == v2)
      {
        for (int p = p1; p <= p2; p++)
          {
            int u = points[p].getV();
            if (u <= v1)
              u += d1;
            else
              u += d2;
            points[p].setU(u);
          }
      }
    else if (v1 < v2)
      {
        for (int p = p1; p <= p2; p++)
          {
            int u = points[p].getV();
            if (u <= v1)
              u += d1;
            else if (u >= v2)
              u += d2;
            else
              {
                u = points[ref1].getU() + Utils.mulDiv(u - v1,
                                                       points[ref2].getU()
                                                       - points[ref1].getU(),
                                                       v2 - v1);
              }
            points[p].setU(u);
          }
      }
    else
      {
        for (int p = p1; p <= p2; p++)
          {
            int u = points[p].getV();
            if (u <= v2)
              u += d2;
            else if (u >= v1)
              u += d1;
            else
              {
                u = points[ref1].getU() + Utils.mulDiv(u - v1,
                                                       points[ref2].getU()
                                                       - points[ref1].getU(),
                                                       v2 - v1);
              }
            points[p].setU(u);
          }
      }
  }

  void alignStrongPoints(int dim)
  {
    AxisHints ax = axis[dim];
    Edge[] edges = ax.edges;
    int numEdges = ax.numEdges;
    short touchFlag;
    if (dim == DIMENSION_HORZ)
      touchFlag = Point.FLAG_DONE_X;
    else
      touchFlag = Point.FLAG_DONE_Y;

    if (numEdges > 0)
      {
        for (int p = 0; p < numPoints; p++)
          {
            Point point = points[p];
            if ((point.getFlags() & touchFlag) != 0)
              continue;
            // If this point is a candidate for weak interpolation, we
            // interpolate it after all strong points have been processed.
            if ((point.getFlags() & Point.FLAG_WEAK_INTERPOLATION) != 0
                && (point.getFlags() & Point.FLAG_INFLECTION) == 0)
              continue;

            int u, ou, fu, delta;
            if (dim == DIMENSION_VERT)
              {
                u = point.getOrigY();
                ou = point.getScaledY();
              }
            else
              {
                u = point.getOrigX();
                ou = point.getScaledX();
              }
            fu = u;
            // Is the point before the first edge?
            Edge edge = edges[0];
            // Inversed vertical dimension.
            delta = edge.fpos - u;
            if (delta >= 0)
              {
                u = edge.pos - (edge.opos - ou);
                storePoint(point, u, dim, touchFlag);
              }
            else
              {
                // Is the point after the last edge?
                edge = edges[numEdges - 1];
                delta = u - edge.fpos;
                if (delta >= 0)
                  {
                    u = edge.pos + (ou - edge.opos);
                    storePoint(point, u, dim, touchFlag);
                  }
                else
                  {
                    // Find enclosing edges.
                    int min = 0;
                    int max = numEdges;
                    int mid, fpos;
                    boolean found = false;
                    while (min < max)
                      {
                        mid = (max + min) / 2;
                        edge = edges[mid];
                        fpos = edge.fpos;
                        if (u < fpos)
                          max = mid;
                        else if (u > fpos)
                          min = mid + 1;
                        else
                          {
                            // Directly on the edge.
                            u = edge.pos;
                            storePoint(point, u, dim, touchFlag);
                            found = true;
                            break;
                          }
                      }
                    if (! found)
                      {
                        Edge before = edges[min - 1];
                        Edge after = edges[min];
                        if (before.scale == 0)
                          {
                            before.scale = Fixed.div16(after.pos - before.pos,
                                                     after.fpos - before.fpos);
                          }
                        u = before.pos + Fixed.mul16(fu - before.fpos,
                                                     before.scale);
                      }
                    storePoint(point, u, dim, touchFlag);
                  }
              }
          }
      }
  }

  private void storePoint(Point p, int u, int dim, short touchFlag)
  {
    if (dim == DIMENSION_HORZ)
      p.setX(u);
    else
      p.setY(u);
    p.addFlags(touchFlag);
  }

  void alignEdgePoints(int dim)
  {
    AxisHints ax = axis[dim];
    Edge[] edges = ax.edges;
    int numEdges = ax.numEdges;
    for (int e = 0; e < numEdges; e++)
      {
        Edge edge = edges[e];
        Segment seg = edge.first;
        do
          {
            Point point = seg.first;
            while (true)
              {
                if (dim == DIMENSION_HORZ)
                  {
                    point.setX(edge.pos);
                    point.addFlags(Point.FLAG_DONE_X);
                  }
                else
                  {
                    point.setY(edge.pos);
                    point.addFlags(Point.FLAG_DONE_Y);
                  }
                if (point == seg.last)
                  break;
                point = point.getNext();
              }
            seg = seg.edgeNext;
          } while (seg != edge.first);
      }
  }

  private int getPointIndex(Point p)
  {
    int idx = -1;
    for (int i = 0; i < numPoints; i++)
      {
        if (p == points[i])
          {
            idx = i;
            break;
          }
      }
    return idx;
  }

  public boolean doAlignEdgePoints()
  {
    return (flags & FontDelegate.FLAG_NO_HINT_EDGE_POINTS) == 0;
  }

  public boolean doAlignStrongPoints()
  {
    return (flags & FontDelegate.FLAG_NO_HINT_STRONG_POINTS) == 0;
  }

  public boolean doAlignWeakPoints()
  {
    return (flags & FontDelegate.FLAG_NO_HINT_WEAK_POINTS) == 0;
  }
}