pdf_stroke_font.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KICAD, a free EDA CAD application.
 *
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program 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
 * of the License, or (at your option) any later version.
 *
 * This program 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 this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#include <plotters/pdf_stroke_font.h>
 
#include <algorithm>
#include <cstdint>
#include <cstdlib>
#include <limits>
 
#include <fmt/format.h>
 
#include <font/glyph.h>
#include <font/glyph_types.h>
#include <advanced_config.h>
#include <plotters/pdf_unicode.h>
 
namespace
{
static constexpr int MAX_SIMPLE_FONT_CODES = 256;
} // anonymous namespace
 
 
PDF_STROKE_FONT_SUBSET::PDF_STROKE_FONT_SUBSET( const KIFONT::STROKE_FONT* aFont, double aUnitsPerEm,
                                                unsigned aSubsetIndex, bool aBold, bool aItalic,
                                                double aStrokeWidthFactor, double aAspectRatio ) :
        m_font( aFont ),
        m_unitsPerEm( aUnitsPerEm ),
        m_resourceName( fmt::format( "/KiCadStroke{}", aSubsetIndex ) ),
        m_cmapName( fmt::format( "KiCadStrokeCMap{}", aSubsetIndex ) ),
        m_widths( MAX_SIMPLE_FONT_CODES, 0.0 ),
        m_nextCode( 1 ),
        m_lastCode( 0 ),
        m_bboxMinX( std::numeric_limits<double>::max() ),
        m_bboxMinY( std::numeric_limits<double>::max() ),
        m_bboxMaxX( std::numeric_limits<double>::lowest() ),
        m_bboxMaxY( std::numeric_limits<double>::lowest() ),
        m_charProcsHandle( -1 ),
        m_fontHandle( -1 ),
        m_toUnicodeHandle( -1 ),
        m_isBold( aBold ),
        m_isItalic( aItalic ),
        m_strokeWidthFactor( aStrokeWidthFactor ),
        m_aspectRatio( aAspectRatio )
{
    GLYPH notdef;
    notdef.m_unicode = 0;
    notdef.m_code = 0;
    notdef.m_glyphIndex = -1;
    notdef.m_name = ".notdef";
    notdef.m_stream.clear();
    notdef.m_width = 0.0;
    notdef.m_minX = 0.0;
    notdef.m_minY = 0.0;
    notdef.m_maxX = 0.0;
    notdef.m_maxY = 0.0;
    notdef.m_charProcHandle = -1;
 
    m_glyphs.push_back( notdef );
    m_bboxMinX = 0.0;
    m_bboxMinY = 0.0;
    m_bboxMaxX = 0.0;
    m_bboxMaxY = 0.0;
}
 
 
// Build the stroked path for a glyph.
// KiCad's internal stroke font glyph coordinates use an inverted Y axis relative to the
// PDF coordinate system we are targeting here.  We therefore flip Y so text renders upright.
std::string PDF_STROKE_FONT_SUBSET::buildGlyphStream( const KIFONT::STROKE_GLYPH* aGlyph ) const
{
    if( !aGlyph )
        return std::string();
 
    fmt::memory_buffer buffer;
 
    const double xEm = m_unitsPerEm * m_aspectRatio;
    const double yEm = m_unitsPerEm;
 
    double lw = m_unitsPerEm * m_strokeWidthFactor;
    fmt::format_to( std::back_inserter( buffer ), "{:.3f} w 1 J 1 j ", lw );
    auto& cfg = ADVANCED_CFG::GetCfg();
 
    for( const std::vector<VECTOR2D>& stroke : *aGlyph )
    {
        bool firstPoint = true;
 
        for( const VECTOR2D& point : stroke )
        {
            double x = ( point.x + cfg.m_PDFStrokeFontXOffset ) * xEm;
            double y = point.y * yEm;
 
            y = -y; // Mirror vertically about baseline (y=0)
            y += cfg.m_PDFStrokeFontYOffset * yEm;
 
            if( firstPoint )
            {
                fmt::format_to( std::back_inserter( buffer ), "{:.3f} {:.3f} m ", x, y );
                firstPoint = false;
            }
            else
            {
                fmt::format_to( std::back_inserter( buffer ), "{:.3f} {:.3f} l ", x, y );
            }
        }
 
        if( !stroke.empty() )
            fmt::format_to( std::back_inserter( buffer ), "S " );
    }
 
    return std::string( buffer.data(), buffer.size() );
}
 
 
bool PDF_STROKE_FONT_SUBSET::Contains( wxUniChar aCode ) const
{
    return m_unicodeToCode.find( aCode ) != m_unicodeToCode.end();
}
 
 
int PDF_STROKE_FONT_SUBSET::EnsureGlyph( wxUniChar aCode )
{
    auto it = m_unicodeToCode.find( aCode );
 
    if( it != m_unicodeToCode.end() )
        return it->second;
 
    if( IsFull() )
        return -1;
 
    int glyphIndex = glyphIndexForUnicode( aCode );
 
    int code = m_nextCode++;
    m_lastCode = std::max( m_lastCode, code );
 
    GLYPH data;
    data.m_unicode = aCode;
    data.m_code = code;
    data.m_glyphIndex = glyphIndex;
    data.m_name = makeGlyphName( code );
    data.m_charProcHandle = -1;
 
    const KIFONT::STROKE_GLYPH* glyph = nullptr;
    BOX2D bbox;
 
    if( m_font )
    {
        glyph = m_font->GetGlyph( glyphIndex );
        bbox = m_font->GetGlyphBoundingBox( glyphIndex );
    }
 
    VECTOR2D origin = bbox.GetOrigin();
    VECTOR2D size = bbox.GetSize();
 
    const double xEm = m_unitsPerEm * m_aspectRatio;
    const double yEm = m_unitsPerEm;
 
    data.m_width = size.x * xEm;
    data.m_minX = origin.x * xEm;
    data.m_minY = origin.y * yEm;
    data.m_maxX = ( origin.x + size.x ) * xEm;
    data.m_maxY = ( origin.y + size.y ) * yEm;
 
    // Invert Y so glyphs render upright in PDF coordinate space.
    {
        // Mirror bounding box vertically about baseline.
        double newMinY = -data.m_maxY;
        double newMaxY = -data.m_minY;
        data.m_minY = newMinY;
        data.m_maxY = newMaxY;
 
        // Apply Y offset to bounding box to match the offset applied to stroke coordinates
        double yOffset = ADVANCED_CFG::GetCfg().m_PDFStrokeFontYOffset * yEm;
        data.m_minY += yOffset;
        data.m_maxY += yOffset;
    }
 
    // Apply X offset to bounding box to match the offset applied to stroke coordinates
    double xOffset = ADVANCED_CFG::GetCfg().m_PDFStrokeFontXOffset * xEm;
    data.m_minX += xOffset;
    data.m_maxX += xOffset;
 
    // Expand bbox by half the stroke width so the d1 clipping rect covers the full painted
    // area, not just the stroke center lines.
    double halfStroke = m_unitsPerEm * m_strokeWidthFactor / 2.0;
    data.m_minX -= halfStroke;
    data.m_minY -= halfStroke;
    data.m_maxX += halfStroke;
    data.m_maxY += halfStroke;
 
    // Build charproc stream: first specify width and bbox (d1 operator) then stroke path.
    double kerningFactor = ADVANCED_CFG::GetCfg().m_PDFStrokeFontKerningFactor;
 
    if( kerningFactor <= 0.0 )
        kerningFactor = 1.0;
 
    std::string strokes = buildGlyphStream( glyph );
    data.m_width = size.x * xEm * kerningFactor;
    data.m_stream = fmt::format( "{:.3f} 0 {:.3f} {:.3f} {:.3f} {:.3f} d1 {}",
                                 data.m_width,
                                 data.m_minX, data.m_minY, data.m_maxX, data.m_maxY,
                                 strokes );
 
    m_widths[code] = data.m_width;
 
    m_bboxMinX = std::min( m_bboxMinX, data.m_minX );
    m_bboxMinY = std::min( m_bboxMinY, data.m_minY );
    m_bboxMaxX = std::max( m_bboxMaxX, data.m_maxX );
    m_bboxMaxY = std::max( m_bboxMaxY, data.m_maxY );
 
    m_glyphs.push_back( std::move( data ) );
    m_unicodeToCode.emplace( aCode, code );
 
    return code;
}
 
 
int PDF_STROKE_FONT_SUBSET::CodeForGlyph( wxUniChar aCode ) const
{
    auto it = m_unicodeToCode.find( aCode );
 
    if( it != m_unicodeToCode.end() )
        return it->second;
 
    return -1;
}
 
 
bool PDF_STROKE_FONT_SUBSET::IsFull() const
{
    return m_nextCode >= MAX_SIMPLE_FONT_CODES;
}
 
 
int PDF_STROKE_FONT_SUBSET::GlyphCount() const
{
    return static_cast<int>( m_glyphs.size() );
}
 
 
int PDF_STROKE_FONT_SUBSET::FirstChar() const
{
    return 0;
}
 
 
int PDF_STROKE_FONT_SUBSET::LastChar() const
{
    return std::max( 0, m_lastCode );
}
 
 
std::string PDF_STROKE_FONT_SUBSET::BuildDifferencesArray() const
{
    int first = FirstChar();
    int last = LastChar();
 
    fmt::memory_buffer buffer;
    fmt::format_to( std::back_inserter( buffer ), "[ {} ", first );
 
    for( int code = first; code <= last; ++code )
    {
        const GLYPH* glyph = glyphForCode( code );
 
        if( glyph )
        fmt::format_to( std::back_inserter( buffer ), "/{} ", glyph->m_name );
        else
        fmt::format_to( std::back_inserter( buffer ), "/.notdef " );
    }
 
    fmt::format_to( std::back_inserter( buffer ), "]" );
    return std::string( buffer.data(), buffer.size() );
}
 
 
std::string PDF_STROKE_FONT_SUBSET::BuildWidthsArray() const
{
    int first = FirstChar();
    int last = LastChar();
 
    fmt::memory_buffer buffer;
    fmt::format_to( std::back_inserter( buffer ), "[" );
 
    for( int code = first; code <= last; ++code )
        fmt::format_to( std::back_inserter( buffer ), " {:g}", m_widths[code] );
 
    fmt::format_to( std::back_inserter( buffer ), " ]" );
    return std::string( buffer.data(), buffer.size() );
}
 
 
std::string PDF_STROKE_FONT_SUBSET::BuildToUnicodeCMap() const
{
    size_t mappingCount = 0;
 
    for( const GLYPH& glyph : m_glyphs )
    {
        if( glyph.m_code == 0 )
            continue;
 
        ++mappingCount;
    }
 
    fmt::memory_buffer buffer;
 
    fmt::format_to( std::back_inserter( buffer ), "/CIDInit /ProcSet findresource begin\n" );
    fmt::format_to( std::back_inserter( buffer ), "12 dict begin\n" );
    fmt::format_to( std::back_inserter( buffer ), "begincmap\n" );
    fmt::format_to( std::back_inserter( buffer ), "/CIDSystemInfo << /Registry (KiCad) /Ordering (StrokeFont) /Supplement 0 >> def\n" );
    fmt::format_to( std::back_inserter( buffer ), "/CMapName /{} def\n", m_cmapName );
    fmt::format_to( std::back_inserter( buffer ), "/CMapType 2 def\n" );
    fmt::format_to( std::back_inserter( buffer ), "1 begincodespacerange\n" );
    fmt::format_to( std::back_inserter( buffer ), "<00> <FF>\n" );
    fmt::format_to( std::back_inserter( buffer ), "endcodespacerange\n" );
 
    fmt::format_to( std::back_inserter( buffer ), "{} beginbfchar\n", mappingCount );
 
    for( const GLYPH& glyph : m_glyphs )
    {
        if( glyph.m_code == 0 )
            continue;
 
        fmt::format_to( std::back_inserter( buffer ), "<{:02X}> <{}>\n", glyph.m_code,
                        FormatPdfUtf16Hex( static_cast<uint32_t>( glyph.m_unicode ) ) );
    }
 
    fmt::format_to( std::back_inserter( buffer ), "endbfchar\n" );
    fmt::format_to( std::back_inserter( buffer ), "endcmap\n" );
    fmt::format_to( std::back_inserter( buffer ), "CMapName currentdict /CMap defineresource pop\n" );
    fmt::format_to( std::back_inserter( buffer ), "end\n" );
    fmt::format_to( std::back_inserter( buffer ), "end\n" );
 
    return std::string( buffer.data(), buffer.size() );
}
 
 
int PDF_STROKE_FONT_SUBSET::glyphIndexForUnicode( wxUniChar aCode ) const
{
    int value = static_cast<int>( aCode );
 
    if( value < ' ' )
        return static_cast<int>( '?' ) - ' ';
 
    int index = value - ' ';
    int count = static_cast<int>( m_font ? m_font->GetGlyphCount() : 0 );
 
    if( index < 0 || index >= count )
        return static_cast<int>( '?' ) - ' ';
 
    return index;
}
 
 
std::string PDF_STROKE_FONT_SUBSET::makeGlyphName( int aCode ) const
{
    return fmt::format( "g{:02X}", aCode );
}
 
 
const PDF_STROKE_FONT_SUBSET::GLYPH* PDF_STROKE_FONT_SUBSET::glyphForCode( int aCode ) const
{
    for( const GLYPH& glyph : m_glyphs )
    {
        if( glyph.m_code == aCode )
            return &glyph;
    }
 
    return nullptr;
}
 
 
PDF_STROKE_FONT_MANAGER::PDF_STROKE_FONT_MANAGER() :
        m_font( KIFONT::STROKE_FONT::LoadFont( wxEmptyString ) ),
        m_unitsPerEm( 1000.0 ),
        m_nextSubsetIndex( 0 )
{
    Reset();
}
 
 
void PDF_STROKE_FONT_MANAGER::Reset()
{
    m_styleGroups.clear();
    m_nextSubsetIndex = 0;
 
    if( !m_font )
        m_font.reset( KIFONT::STROKE_FONT::LoadFont( wxEmptyString ) );
}
 
 
PDF_STROKE_FONT_MANAGER::STYLE_KEY PDF_STROKE_FONT_MANAGER::styleKey( bool aBold, bool aItalic,
                                                                      int aStrokeWidth, int aFontWidth,
                                                                      int aFontHeight )
{
    int strokeWidth = std::abs( aStrokeWidth );
    int fontWidth = std::abs( aFontWidth );
    int fontHeight = strokeWidth > 0 ? std::abs( aFontHeight ) : 0;
    return { aBold, aItalic, strokeWidth, fontWidth, fontHeight };
}
 
 
void PDF_STROKE_FONT_MANAGER::EncodeString( const wxString& aText, std::vector<PDF_STROKE_FONT_RUN>* aRuns,
                                            int aStrokeWidth, int aFontWidth, int aFontHeight, bool aBold,
                                            bool aItalic )
{
    if( !aRuns )
        return;
 
    aRuns->clear();
 
    if( aText.empty() )
        return;
 
    PDF_STROKE_FONT_SUBSET* currentSubset = nullptr;
    std::string             currentBytes;
 
    for( wxUniChar ch : aText )
    {
        PDF_STROKE_FONT_SUBSET* subset = ensureSubsetForGlyph( ch, aStrokeWidth, aFontWidth, aFontHeight,
                                                               aBold, aItalic );
 
        if( !subset )
            continue;
 
        int code = subset->EnsureGlyph( ch );
 
        if( code < 0 )
            continue;
 
        if( subset != currentSubset )
        {
            if( !currentBytes.empty() && currentSubset )
                aRuns->push_back( { currentSubset, currentBytes, aBold, aItalic } );
 
            currentSubset = subset;
            currentBytes.clear();
        }
 
        currentBytes.push_back( static_cast<char>( code ) );
    }
 
    if( !currentBytes.empty() && currentSubset )
        aRuns->push_back( { currentSubset, std::move( currentBytes ), aBold, aItalic } );
}
 
PDF_STROKE_FONT_SUBSET* PDF_STROKE_FONT_MANAGER::ensureSubsetForGlyph( wxUniChar aCode, int aStrokeWidth,
                                                                       int aFontWidth, int aFontHeight,
                                                                       bool aBold, bool aItalic )
{
    int strokeWidth = std::abs( aStrokeWidth );
    int fontWidth = std::abs( aFontWidth );
    int fontHeight = std::abs( aFontHeight );
 
    double widthFactor;
 
    if( strokeWidth > 0 && fontHeight > 0 )
    {
        widthFactor = static_cast<double>( strokeWidth ) / static_cast<double>( fontHeight );
    }
    else
    {
        widthFactor = ADVANCED_CFG::GetCfg().m_PDFStrokeFontWidthFactor;
 
        if( widthFactor <= 0.0 )
            widthFactor = 0.04;
 
        if( aBold )
        {
            double boldMul = ADVANCED_CFG::GetCfg().m_PDFStrokeFontBoldMultiplier;
 
            if( boldMul < 1.0 )
                boldMul = 1.0;
 
            widthFactor *= boldMul;
        }
    }
 
    double aspectRatio = 1.0;
 
    if( fontHeight > 0 && fontWidth > 0 )
        aspectRatio = static_cast<double>( fontWidth ) / static_cast<double>( fontHeight );
 
    STYLE_KEY    key = styleKey( aBold, aItalic, aStrokeWidth, aFontWidth, aFontHeight );
    STYLE_GROUP& group = m_styleGroups[key];
 
    for( const std::unique_ptr<PDF_STROKE_FONT_SUBSET>& subset : group.subsets )
    {
        if( subset->Contains( aCode ) )
            return subset.get();
    }
 
    for( const std::unique_ptr<PDF_STROKE_FONT_SUBSET>& subset : group.subsets )
    {
        if( subset->IsFull() )
            continue;
 
        if( subset->EnsureGlyph( aCode ) >= 0 )
            return subset.get();
    }
 
    unsigned subsetIndex = m_nextSubsetIndex++;
    auto newSubset = std::make_unique<PDF_STROKE_FONT_SUBSET>( m_font.get(), m_unitsPerEm, subsetIndex, aBold, aItalic,
                                                               widthFactor, aspectRatio );
    PDF_STROKE_FONT_SUBSET* subsetPtr = newSubset.get();
    subsetPtr->EnsureGlyph( aCode );
    group.subsets.emplace_back( std::move( newSubset ) );
    return subsetPtr;
}
 
std::vector<PDF_STROKE_FONT_SUBSET*> PDF_STROKE_FONT_MANAGER::AllSubsets() const
{
    std::vector<PDF_STROKE_FONT_SUBSET*> out;
 
    for( const auto& [key, group] : m_styleGroups )
    {
        (void) key;
        for( const auto& up : group.subsets )
            out.push_back( up.get() );
    }
    return out;
}