FTContour.cpp

Branch :
Show log
Commit
Author : sammy
Date : 2008-04-21 21:48:03
Hash : 7e74380f
Message : * Inset/outset contour support for fonts, by Eric Beets. For now, only contours with exactly the same number of points are generated.
src/FTContour.cpp
/*
 * FTGL - OpenGL font library
 *
 * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
 *               2008 Sam Hocevar <sam@zoy.org>
 *               2008 Éric Beets <ericbeets@free.fr>
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * Alternatively, you can redistribute and/or modify this software under
 * the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License,
 * or (at your option) any later version.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this software; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA.
 */

#include "config.h"

#include "FTContour.h"

#include <math.h>

static const float BEZIER_STEP_SIZE = 0.2f;


void FTContour::AddPoint(FTPoint point)
{
    if(pointList.empty() || (point != pointList[pointList.size() - 1]
                              && point != pointList[0]))
    {
        pointList.push_back(point);
    }
}


void FTContour::evaluateQuadraticCurve(FTPoint A, FTPoint B, FTPoint C)
{
    for(unsigned int i = 0; i <= (1.0f / BEZIER_STEP_SIZE); i++)
    {
        float t = static_cast<float>(i) * BEZIER_STEP_SIZE;

        FTPoint U = (1.0f - t) * A + t * B;
        FTPoint V = (1.0f - t) * B + t * C;

        AddPoint((1.0f - t) * U + t * V);
    }
}

void FTContour::evaluateCubicCurve(FTPoint A, FTPoint B, FTPoint C, FTPoint D)
{
    for(unsigned int i = 0; i <= (1.0f / BEZIER_STEP_SIZE); i++)
    {
        float t = static_cast<float>(i) * BEZIER_STEP_SIZE;

        FTPoint U = (1.0f - t) * A + t * B;
        FTPoint V = (1.0f - t) * B + t * C;
        FTPoint W = (1.0f - t) * C + t * D;

        FTPoint M = (1.0f - t) * U + t * V;
        FTPoint N = (1.0f - t) * V + t * W;

        AddPoint((1.0f - t) * M + t * N);
    }
}

void FTContour::AddFrontPoint(FTPoint point)
{
    if(frontPointList.empty() || (point != frontPointList[pointList.size() - 1]
                                   && point != frontPointList[0]))
    {
        frontPointList.push_back(point);
    }
}

void FTContour::AddBackPoint(FTPoint point)
{
    if(backPointList.empty() || (point != backPointList[pointList.size() - 1]
                                  && point != backPointList[0]))
    {
        backPointList.push_back(point);
    }
}

FTGL_DOUBLE FTContour::NormVector(const FTPoint &v)
{
    return sqrt(v.X() * v.X() + v.Y() * v.Y());
}

void FTContour::RotationMatrix(const FTPoint &a, const FTPoint &b, FTGL_DOUBLE *matRot, FTGL_DOUBLE *invRot)
{
    FTPoint abVect(b.X() - a.X(), b.Y() - a.Y(), 0);
    FTGL_DOUBLE abNorm = NormVector(abVect);
    invRot[0] = matRot[0] = -abVect.X() / abNorm;
    invRot[2] = matRot[1] = -abVect.Y() / abNorm;
    invRot[1] = matRot[2] =  abVect.Y() / abNorm;
    invRot[3] = matRot[3] = -abVect.X() / abNorm;
}

void FTContour::MultMatrixVect(FTGL_DOUBLE *mat, FTPoint &v)
{
    FTPoint res;
    res.X(v.X() * mat[0] + v.Y() * mat[1]);
    res.Y(v.X() * mat[2] + v.Y() * mat[3]);
    v.X(res.X());
    v.Y(res.Y());
}

void FTContour::ComputeBisec(FTPoint &v, double d)
{
    int sgn = 1;
    if((v.Y() / NormVector(v)) < 0)
        sgn = -1;
    double tg = sgn * sqrt((NormVector(v) - v.X()) / (NormVector(v) + v.X()));
    v.X(-d * tg);
    v.Y(d);
}

FTPoint FTContour::ComputeOutsetPoint(FTPoint a, FTPoint b, FTPoint c, FTGL_DOUBLE dist)
{
    FTGL_DOUBLE mat[4], inv[4];
    /* Build the rotation matrix from 'ab' vector */
    RotationMatrix(b, a, mat, inv);
    /* 'h' is the second vector 'bc' */
    FTPoint h = c - b;
    /* Apply the rotation to the second vector 'bc' */
    MultMatrixVect(mat, h);
    /* Compute the vector bisecting 'bh' */
    ComputeBisec(h, dist);
    /* Apply the inverted rotation matrix to 'bh' */
    MultMatrixVect(inv, h);
    /* Translate the vector 'bh' to the second point 'b' to have the point 'h' */
    return b + h;
}

void FTContour::outsetContour(float frontOutset, float backOutset)
{
    size_t size = PointCount();
    FTPoint vOutsetF, vOutsetB;
    for(unsigned int pointIndex = 0; pointIndex < size; ++pointIndex)
    {
        int prev = (pointIndex%size + size - 1) % size;
        int cur = pointIndex%size;
        int next = (pointIndex%size + 1) % size;

        if(frontOutset != 0.0f)
        {
            vOutsetF = ComputeOutsetPoint(Point(prev), Point(cur), Point(next),
                                          frontOutset);
            AddFrontPoint(vOutsetF);
        }
        if(backOutset != 0.0f)
        {
            vOutsetB = ComputeOutsetPoint(Point(prev), Point(cur), Point(next),
                                          backOutset);
            AddBackPoint(vOutsetB);
        }
    }
}

FTContour::FTContour(FT_Vector* contour, char* tags, unsigned int n,
                     float frontOutset, float backOutset)
{
    for(unsigned int i = 0; i < n; ++ i)
    {
        if(tags[i] == FT_Curve_Tag_On || n < 2)
        {
            AddPoint(FTPoint(contour[i]));
            continue;
        }

        FTPoint cur(contour[i]);
        FTPoint prev = (pointList.size() == 0 || i == 0)
                       ? FTPoint(contour[n - 1])
                       : pointList[pointList.size() - 1];
        FTPoint next = (i == n - 1)
                       ? (pointList.size() == 0)
                         ? FTPoint(contour[0])
                         : pointList[0]
                       : FTPoint(contour[i + 1]);

        if(tags[i] == FT_Curve_Tag_Conic)
        {
            while(tags[(i == n - 1) ? 0 : i + 1] == FT_Curve_Tag_Conic)
            {
                next = (cur + next) * 0.5f;

                evaluateQuadraticCurve(prev, cur, next);
                ++i;

                prev = next;
                cur = FTPoint(contour[i]);
                next = (i == n - 1)
                       ? pointList[0]
                       : FTPoint(contour[i + 1]);
            }

            evaluateQuadraticCurve(prev, cur, next);
            continue;
        }

        if(tags[i] == FT_Curve_Tag_Cubic)
        {
            FTPoint cur2 = next;

            FTPoint next = (i == n - 2)
                           ? pointList[0]
                           : FTPoint(contour[i + 2]);

            evaluateCubicCurve(prev, cur, cur2, next);
            ++i;
            continue;
        }
    }

    /* Create (or not) front outset and/or back outset */
    outsetContour(frontOutset, backOutset);
}
kc3-lang/ftgl/src/FTContour.cpp

Commit

kc3-lang/ftgl /src/FTContour.cpp
