pdf_test_utils.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 <algorithm>
 
#include <qa_utils/file_utils.h>
#include <qa_utils/pdf_test_utils.h>
#include <gal/color4d.h>
 
#include <wx/filefn.h>
#include <wx/ffile.h>
#include <wx/utils.h>
#include <wx/image.h>
#include <wx/imagpng.h>
 
#include <zlib.h>
 
SIMPLE_RENDER_SETTINGS::SIMPLE_RENDER_SETTINGS()
{
    m_background = KIGFX::COLOR4D( 1.0, 1.0, 1.0, 1.0 );
    m_grid = KIGFX::COLOR4D( 0.8, 0.8, 0.8, 1.0 );
    m_cursor = KIGFX::COLOR4D( 0.0, 0.0, 0.0, 1.0 );
}
 
KIGFX::COLOR4D SIMPLE_RENDER_SETTINGS::GetColor( const KIGFX::VIEW_ITEM*, int ) const
{
    return KIGFX::COLOR4D( 0.0, 0.0, 0.0, 1.0 );
}
 
TEXT_ATTRIBUTES BuildTextAttributes( int aSizeIu, int aStrokeWidth, bool aBold, bool aItalic )
{
    TEXT_ATTRIBUTES attrs;
    attrs.m_Size = VECTOR2I( aSizeIu, aSizeIu );
    attrs.m_StrokeWidth = aStrokeWidth;
    attrs.m_Multiline = false;
    attrs.m_Italic = aItalic;
    attrs.m_Bold = aBold;
    attrs.m_Halign = GR_TEXT_H_ALIGN_LEFT;
    attrs.m_Valign = GR_TEXT_V_ALIGN_BOTTOM;
    attrs.m_Angle = ANGLE_0;
    attrs.m_Mirrored = false;
    return attrs;
}
 
std::unique_ptr<KIFONT::STROKE_FONT> LoadStrokeFontUnique()
{
    return std::unique_ptr<KIFONT::STROKE_FONT>( KIFONT::STROKE_FONT::LoadFont( wxEmptyString ) );
}
 
static void append_decompressed_streams( std::string& aBuffer )
{
    std::string aggregate = aBuffer;
    size_t pos = 0;
 
    while( true )
    {
        size_t streamPos = aBuffer.find( "stream\n", pos );
 
        if( streamPos == std::string::npos )
            break;
 
        size_t endPos = aBuffer.find( "endstream", streamPos );
 
        if( endPos == std::string::npos )
            break;
 
        size_t dataStart = streamPos + 7; // skip "stream\n"
        size_t dataLen = ( endPos > dataStart ) ? ( endPos - dataStart ) : 0;
 
        if( dataLen > 0 )
        {
            // Trailing newline after the zlib payload is common in PDF writers; strip it so
            // inflate does not see leftover input.
            while( dataLen > 0
                   && ( aBuffer[dataStart + dataLen - 1] == '\n' || aBuffer[dataStart + dataLen - 1] == '\r' ) )
            {
                --dataLen;
            }
 
            const unsigned char* data = reinterpret_cast<const unsigned char*>( aBuffer.data() + dataStart );
            z_stream             zs{};
            zs.next_in = const_cast<Bytef*>( data );
            zs.avail_in = static_cast<uInt>( dataLen );
 
            if( inflateInit( &zs ) == Z_OK )
            {
                // Grow until inflate finishes.
                std::string out;
                out.resize( std::max( dataLen * 8 + 256, size_t( 4096 ) ) );
                int ret = Z_OK;
 
                for( ;; )
                {
                    zs.next_out = reinterpret_cast<Bytef*>( out.data() ) + zs.total_out;
                    zs.avail_out = static_cast<uInt>( out.size() - zs.total_out );
                    ret = inflate( &zs, Z_FINISH );
 
                    if( ret != Z_BUF_ERROR )
                        break;
 
                    // Z_BUF_ERROR also reports exhausted input, which a bigger output buffer
                    // cannot cure. Doubling on that alone allocates until it throws
                    if( zs.avail_out > 0 )
                        break;
 
                    out.resize( out.size() * 2 );
                }
 
                if( ret == Z_STREAM_END )
                {
                    out.resize( zs.total_out );
                    aggregate += out;
                }
 
                inflateEnd( &zs );
            }
        }
 
        pos = endPos + 9; // skip past "endstream"
    }
 
    aBuffer.swap( aggregate );
}
 
bool ReadPdfWithDecompressedStreams( const wxString& aPdfPath, std::string& aOutBuffer )
{
    wxFFile file( aPdfPath, "rb" );
 
    if( !file.IsOpened() )
        return false;
 
    wxFileOffset len = file.Length();
    if( len <= 0 )
        return false;
 
    aOutBuffer.resize( static_cast<size_t>( len ) );
    file.Read( aOutBuffer.data(), len );
 
    append_decompressed_streams( aOutBuffer );
    return true;
}
 
int CountOccurrences( const std::string& aHaystack, const std::string& aNeedle )
{
    if( aNeedle.empty() )
        return 0;
 
    int count = 0;
    size_t pos = 0;
 
    while( true )
    {
        size_t p = aHaystack.find( aNeedle, pos );
        if( p == std::string::npos )
            break;
        ++count;
        pos = p + 1; // allow overlaps
    }
 
    return count;
}
 
bool RasterizePdfCountDark( const wxString& aPdfPath, int aDpi, int aNearWhiteThresh,
                            long& aOutDarkPixels )
{
    aOutDarkPixels = 0;
 
    KI_TEST::SCOPED_TEMP_DIR rasterDir( "kicad_pdf_raster" );
    wxString rasterBase = rasterDir.ChildPathStr( "raster" );
    wxString cmd = wxString::Format( wxT( "pdftoppm -r %d -singlefile -png \"%s\" \"%s\"" ),
                                     aDpi, aPdfPath, rasterBase );
    int ret = wxExecute( cmd, wxEXEC_SYNC );
 
    if( ret != 0 )
        return false;
 
    wxString pngPath = rasterBase + wxT( ".png" );
 
    if( !wxFileExists( pngPath ) )
        return false;
 
    if( !wxImage::FindHandler( wxBITMAP_TYPE_PNG ) )
        wxImage::AddHandler( new wxPNGHandler );
 
    wxImage img( pngPath );
    if( !img.IsOk() )
        return false;
 
    int w = img.GetWidth();
    int h = img.GetHeight();
 
    long dark = 0;
    for( int y = 0; y < h; ++y )
    {
        for( int x = 0; x < w; ++x )
        {
            unsigned char r = img.GetRed( x, y );
            unsigned char g = img.GetGreen( x, y );
            unsigned char b = img.GetBlue( x, y );
 
            if( r < aNearWhiteThresh || g < aNearWhiteThresh || b < aNearWhiteThresh )
                ++dark;
        }
    }
 
    aOutDarkPixels = dark;
 
    return true;
}